Use bool parameters in messages.* functions.

20 files changed, 93 insertions, 266 deletions

diff --git a/td/telegram/AttachMenuManager.cpp b/td/telegram/AttachMenuManager.cpp
index 3247e1d70..f2d59adaf 100644
--- a/td/telegram/AttachMenuManager.cpp
+++ b/td/telegram/AttachMenuManager.cpp
@@ -95,13 +95,9 @@ class ToggleBotInAttachMenuQuery final : public Td::ResultHandler {
   explicit ToggleBotInAttachMenuQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
   }
 
-  void send(tl_object_ptr<telegram_api::InputUser> &&input_user, bool is_added, bool allow_write_access) {
-    int32 flags = 0;
-    if (is_added && allow_write_access) {
-      flags |= telegram_api::messages_toggleBotInAttachMenu::WRITE_ALLOWED_MASK;
-    }
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_toggleBotInAttachMenu(flags, false /*ignored*/, std::move(input_user), is_added)));
+  void send(telegram_api::object_ptr<telegram_api::InputUser> &&input_user, bool is_added, bool allow_write_access) {
+    send_query(G()->net_query_creator().create(telegram_api::messages_toggleBotInAttachMenu(
+        0, is_added && allow_write_access, std::move(input_user), is_added)));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/BackgroundManager.cpp b/td/telegram/BackgroundManager.cpp
index b9925f840..c8dce7e15 100644
--- a/td/telegram/BackgroundManager.cpp
+++ b/td/telegram/BackgroundManager.cpp
@@ -137,15 +137,9 @@ class SetChatWallPaperQuery final : public Td::ResultHandler {
     if (old_message_id.is_valid()) {
       flags |= telegram_api::messages_setChatWallPaper::ID_MASK;
     }
-    if (for_both) {
-      flags |= telegram_api::messages_setChatWallPaper::FOR_BOTH_MASK;
-    }
-    if (revert) {
-      flags |= telegram_api::messages_setChatWallPaper::REVERT_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_setChatWallPaper(
-        flags, false /*ignored*/, false /*ignored*/, std::move(input_peer), std::move(input_wallpaper),
-        std::move(settings), old_message_id.get_server_message_id().get())));
+        flags, for_both, revert, std::move(input_peer), std::move(input_wallpaper), std::move(settings),
+        old_message_id.get_server_message_id().get())));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/CallbackQueriesManager.cpp b/td/telegram/CallbackQueriesManager.cpp
index 81c95cc90..e4ed19ffa 100644
--- a/td/telegram/CallbackQueriesManager.cpp
+++ b/td/telegram/CallbackQueriesManager.cpp
@@ -47,27 +47,29 @@ class GetBotCallbackAnswerQuery final : public Td::ResultHandler {
 
     int32 flags = 0;
     BufferSlice data;
+    bool is_game = false;
     CHECK(payload != nullptr);
     switch (payload->get_id()) {
       case td_api::callbackQueryPayloadData::ID:
-        flags = telegram_api::messages_getBotCallbackAnswer::DATA_MASK;
         data = BufferSlice(static_cast<const td_api::callbackQueryPayloadData *>(payload.get())->data_);
         break;
       case td_api::callbackQueryPayloadDataWithPassword::ID:
         CHECK(password != nullptr);
-        flags = telegram_api::messages_getBotCallbackAnswer::DATA_MASK |
-                telegram_api::messages_getBotCallbackAnswer::PASSWORD_MASK;
+        flags = telegram_api::messages_getBotCallbackAnswer::PASSWORD_MASK;
         data = BufferSlice(static_cast<const td_api::callbackQueryPayloadDataWithPassword *>(payload.get())->data_);
         break;
       case td_api::callbackQueryPayloadGame::ID:
-        flags = telegram_api::messages_getBotCallbackAnswer::GAME_MASK;
+        is_game = true;
         break;
       default:
         UNREACHABLE();
     }
+    if (!is_game) {
+      flags |= telegram_api::messages_getBotCallbackAnswer::DATA_MASK;
+    }
 
     auto net_query = G()->net_query_creator().create(telegram_api::messages_getBotCallbackAnswer(
-        flags, false /*ignored*/, std::move(input_peer), message_id.get_server_message_id().get(), std::move(data),
+        flags, is_game, std::move(input_peer), message_id.get_server_message_id().get(), std::move(data),
         std::move(password)));
     net_query->need_resend_on_503_ = false;
     send_query(std::move(net_query));
@@ -108,14 +110,11 @@ class SetBotCallbackAnswerQuery final : public Td::ResultHandler {
     if (!text.empty()) {
       flags |= telegram_api::messages_setBotCallbackAnswer::MESSAGE_MASK;
     }
-    if (show_alert) {
-      flags |= telegram_api::messages_setBotCallbackAnswer::ALERT_MASK;
-    }
     if (!url.empty()) {
       flags |= telegram_api::messages_setBotCallbackAnswer::URL_MASK;
     }
-    send_query(G()->net_query_creator().create(telegram_api::messages_setBotCallbackAnswer(
-        flags, false /*ignored*/, callback_query_id, text, url, cache_time)));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_setBotCallbackAnswer(flags, show_alert, callback_query_id, text, url, cache_time)));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/ChatManager.cpp b/td/telegram/ChatManager.cpp
index 70d4d4ac3..6c9313ddd 100644
--- a/td/telegram/ChatManager.cpp
+++ b/td/telegram/ChatManager.cpp
@@ -5905,8 +5905,8 @@ bool ChatManager::on_get_channel_error(ChannelId channel_id, const Status &statu
     if (c->status.is_member()) {
       LOG(INFO) << "Emulate leaving " << channel_id;
       // TODO we also may try to write to a public channel
-      telegram_api::channelForbidden channel_forbidden(0 /*ignored*/, !c->is_megagroup, c->is_megagroup,
-                                                       channel_id.get(), c->access_hash, c->title, 0);
+      telegram_api::channelForbidden channel_forbidden(0, !c->is_megagroup, c->is_megagroup, channel_id.get(),
+                                                       c->access_hash, c->title, 0);
       on_get_channel_forbidden(channel_forbidden, "CHANNEL_PRIVATE");
     } else if (!c->status.is_banned()) {
       if (!c->usernames.is_empty()) {
diff --git a/td/telegram/DialogInviteLinkManager.cpp b/td/telegram/DialogInviteLinkManager.cpp
index 114053045..9836c7b0b 100644
--- a/td/telegram/DialogInviteLinkManager.cpp
+++ b/td/telegram/DialogInviteLinkManager.cpp
@@ -124,12 +124,6 @@ class ExportChatInviteQuery final : public Td::ResultHandler {
     if (usage_limit > 0) {
       flags |= telegram_api::messages_exportChatInvite::USAGE_LIMIT_MASK;
     }
-    if (creates_join_request) {
-      flags |= telegram_api::messages_exportChatInvite::REQUEST_NEEDED_MASK;
-    }
-    if (is_permanent) {
-      flags |= telegram_api::messages_exportChatInvite::LEGACY_REVOKE_PERMANENT_MASK;
-    }
     if (!title.empty()) {
       flags |= telegram_api::messages_exportChatInvite::TITLE_MASK;
     }
@@ -138,7 +132,7 @@ class ExportChatInviteQuery final : public Td::ResultHandler {
     }
 
     send_query(G()->net_query_creator().create(telegram_api::messages_exportChatInvite(
-        flags, false /*ignored*/, false /*ignored*/, std::move(input_peer), expire_date, usage_limit, title,
+        flags, is_permanent, creates_join_request, std::move(input_peer), expire_date, usage_limit, title,
         subscription_pricing.get_input_stars_subscription_pricing())));
   }
 
@@ -191,9 +185,8 @@ class EditChatInviteLinkQuery final : public Td::ResultHandler {
                telegram_api::messages_editExportedChatInvite::USAGE_LIMIT_MASK |
                telegram_api::messages_editExportedChatInvite::REQUEST_NEEDED_MASK;
     }
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_editExportedChatInvite(flags, false /*ignored*/, std::move(input_peer), invite_link,
-                                                      expire_date, usage_limit, creates_join_request, title)));
+    send_query(G()->net_query_creator().create(telegram_api::messages_editExportedChatInvite(
+        flags, false, std::move(input_peer), invite_link, expire_date, usage_limit, creates_join_request, title)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -294,12 +287,8 @@ class GetExportedChatInvitesQuery final : public Td::ResultHandler {
       flags |= telegram_api::messages_getExportedChatInvites::OFFSET_DATE_MASK;
       flags |= telegram_api::messages_getExportedChatInvites::OFFSET_LINK_MASK;
     }
-    if (is_revoked) {
-      flags |= telegram_api::messages_getExportedChatInvites::REVOKED_MASK;
-    }
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_getExportedChatInvites(flags, false /*ignored*/, std::move(input_peer),
-                                                      std::move(input_user), offset_date, offset_invite_link, limit)));
+    send_query(G()->net_query_creator().create(telegram_api::messages_getExportedChatInvites(
+        flags, is_revoked, std::move(input_peer), std::move(input_user), offset_date, offset_invite_link, limit)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -406,11 +395,8 @@ class GetChatInviteImportersQuery final : public Td::ResultHandler {
     }
 
     int32 flags = telegram_api::messages_getChatInviteImporters::LINK_MASK;
-    if (subscription_expired) {
-      flags |= telegram_api::messages_getChatInviteImporters::SUBSCRIPTION_EXPIRED_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_getChatInviteImporters(
-        flags, false /*ignored*/, false /*ignored*/, std::move(input_peer), invite_link, string(), offset_date,
+        flags, false, subscription_expired, std::move(input_peer), invite_link, string(), offset_date,
         r_input_user.move_as_ok(), limit)));
   }
 
@@ -467,9 +453,8 @@ class RevokeChatInviteLinkQuery final : public Td::ResultHandler {
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Write);
     CHECK(input_peer != nullptr);
 
-    int32 flags = telegram_api::messages_editExportedChatInvite::REVOKED_MASK;
     send_query(G()->net_query_creator().create(telegram_api::messages_editExportedChatInvite(
-        flags, false /*ignored*/, std::move(input_peer), invite_link, 0, 0, false, string())));
+        0, true, std::move(input_peer), invite_link, 0, 0, false, string())));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/DialogManager.cpp b/td/telegram/DialogManager.cpp
index 64d95b332..7fae12ea4 100644
--- a/td/telegram/DialogManager.cpp
+++ b/td/telegram/DialogManager.cpp
@@ -777,11 +777,9 @@ class ReorderPinnedDialogsQuery final : public Td::ResultHandler {
 
   void send(FolderId folder_id, const vector<DialogId> &dialog_ids) {
     folder_id_ = folder_id;
-    int32 flags = telegram_api::messages_reorderPinnedDialogs::FORCE_MASK;
     send_query(G()->net_query_creator().create(
         telegram_api::messages_reorderPinnedDialogs(
-            flags, true /*ignored*/, folder_id.get(),
-            td_->dialog_manager_->get_input_dialog_peers(dialog_ids, AccessRights::Read)),
+            0, true, folder_id.get(), td_->dialog_manager_->get_input_dialog_peers(dialog_ids, AccessRights::Read)),
         {{folder_id_}}));
   }
 
@@ -1089,12 +1087,8 @@ class ToggleDialogUnreadMarkQuery final : public Td::ResultHandler {
       return on_error(Status::Error(400, "Can't access the chat"));
     }
 
-    int32 flags = 0;
-    if (is_marked_as_unread) {
-      flags |= telegram_api::messages_markDialogUnread::UNREAD_MASK;
-    }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_markDialogUnread(flags, false /*ignored*/, std::move(input_peer)), {{dialog_id}}));
+        telegram_api::messages_markDialogUnread(0, is_marked_as_unread, std::move(input_peer)), {{dialog_id}}));
   }
 
   void on_result(BufferSlice packet) final {
@@ -1140,12 +1134,8 @@ class ToggleDialogPinQuery final : public Td::ResultHandler {
       return on_error(Status::Error(400, "Can't access the chat"));
     }
 
-    int32 flags = 0;
-    if (is_pinned) {
-      flags |= telegram_api::messages_toggleDialogPin::PINNED_MASK;
-    }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_toggleDialogPin(flags, false /*ignored*/, std::move(input_peer)), {{dialog_id}}));
+        telegram_api::messages_toggleDialogPin(0, is_pinned, std::move(input_peer)), {{dialog_id}}));
   }
 
   void on_result(BufferSlice packet) final {
@@ -1190,12 +1180,8 @@ class ToggleDialogTranslationsQuery final : public Td::ResultHandler {
       return on_error(Status::Error(400, "Can't access the chat"));
     }
 
-    int32 flags = 0;
-    if (!is_translatable) {
-      flags |= telegram_api::messages_togglePeerTranslations::DISABLED_MASK;
-    }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_togglePeerTranslations(flags, false /*ignored*/, std::move(input_peer)), {{dialog_id}}));
+        telegram_api::messages_togglePeerTranslations(0, !is_translatable, std::move(input_peer)), {{dialog_id}}));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/DialogParticipantManager.cpp b/td/telegram/DialogParticipantManager.cpp
index 3f4b27b48..ab61a530d 100644
--- a/td/telegram/DialogParticipantManager.cpp
+++ b/td/telegram/DialogParticipantManager.cpp
@@ -104,7 +104,7 @@ class GetChatJoinRequestsQuery final : public Td::ResultHandler {
       r_input_user = make_tl_object<telegram_api::inputUserEmpty>();
     }
 
-    int32 flags = telegram_api::messages_getChatInviteImporters::REQUESTED_MASK;
+    int32 flags = 0;
     if (!invite_link.empty()) {
       flags |= telegram_api::messages_getChatInviteImporters::LINK_MASK;
     }
@@ -112,8 +112,7 @@ class GetChatJoinRequestsQuery final : public Td::ResultHandler {
       flags |= telegram_api::messages_getChatInviteImporters::Q_MASK;
     }
     send_query(G()->net_query_creator().create(telegram_api::messages_getChatInviteImporters(
-        flags, false /*ignored*/, false /*ignored*/, std::move(input_peer), invite_link, query, offset_date,
-        r_input_user.move_as_ok(), limit)));
+        flags, true, false, std::move(input_peer), invite_link, query, offset_date, r_input_user.move_as_ok(), limit)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -176,12 +175,8 @@ class HideChatJoinRequestQuery final : public Td::ResultHandler {
 
     TRY_RESULT_PROMISE(promise_, input_user, td_->user_manager_->get_input_user(user_id));
 
-    int32 flags = 0;
-    if (approve) {
-      flags |= telegram_api::messages_hideChatJoinRequest::APPROVED_MASK;
-    }
-    send_query(G()->net_query_creator().create(telegram_api::messages_hideChatJoinRequest(
-        flags, false /*ignored*/, std::move(input_peer), std::move(input_user))));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_hideChatJoinRequest(0, approve, std::move(input_peer), std::move(input_user))));
   }
 
   void on_result(BufferSlice packet) final {
@@ -215,14 +210,11 @@ class HideAllChatJoinRequestsQuery final : public Td::ResultHandler {
     CHECK(input_peer != nullptr);
 
     int32 flags = 0;
-    if (approve) {
-      flags |= telegram_api::messages_hideAllChatJoinRequests::APPROVED_MASK;
-    }
     if (!invite_link.empty()) {
       flags |= telegram_api::messages_hideAllChatJoinRequests::LINK_MASK;
     }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_hideAllChatJoinRequests(flags, false /*ignored*/, std::move(input_peer), invite_link)));
+        telegram_api::messages_hideAllChatJoinRequests(flags, approve, std::move(input_peer), invite_link)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -501,12 +493,8 @@ class DeleteChatUserQuery final : public Td::ResultHandler {
   }
 
   void send(ChatId chat_id, tl_object_ptr<telegram_api::InputUser> &&input_user, bool revoke_messages) {
-    int32 flags = 0;
-    if (revoke_messages) {
-      flags |= telegram_api::messages_deleteChatUser::REVOKE_HISTORY_MASK;
-    }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_deleteChatUser(flags, false /*ignored*/, chat_id.get(), std::move(input_user))));
+        telegram_api::messages_deleteChatUser(0, revoke_messages, chat_id.get(), std::move(input_user))));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/DraftMessage.cpp b/td/telegram/DraftMessage.cpp
index 2e7455a03..ebfda8e6b 100644
--- a/td/telegram/DraftMessage.cpp
+++ b/td/telegram/DraftMessage.cpp
@@ -45,6 +45,8 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
     vector<telegram_api::object_ptr<telegram_api::MessageEntity>> input_message_entities;
     telegram_api::object_ptr<telegram_api::InputMedia> media;
     int64 message_effect_id = 0;
+    bool disable_web_page_preview = false;
+    bool invert_media = false;
     if (draft_message != nullptr) {
       CHECK(!draft_message->is_local());
       input_reply_to = draft_message->message_input_reply_to_.get_input_reply_to(td_, MessageId() /*TODO*/);
@@ -52,9 +54,9 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
         flags |= telegram_api::messages_saveDraft::REPLY_TO_MASK;
       }
       if (draft_message->input_message_text_.disable_web_page_preview) {
-        flags |= telegram_api::messages_saveDraft::NO_WEBPAGE_MASK;
+        disable_web_page_preview = true;
       } else if (draft_message->input_message_text_.show_above_text) {
-        flags |= telegram_api::messages_saveDraft::INVERT_MEDIA_MASK;
+        invert_media = true;
       }
       input_message_entities = get_input_message_entities(
           td_->user_manager_.get(), draft_message->input_message_text_.text.entities, "SaveDraftMessageQuery");
@@ -72,7 +74,7 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
     }
     send_query(G()->net_query_creator().create(
         telegram_api::messages_saveDraft(
-            flags, false /*ignored*/, false /*ignored*/, std::move(input_reply_to), std::move(input_peer),
+            flags, disable_web_page_preview, invert_media, std::move(input_reply_to), std::move(input_peer),
             draft_message == nullptr ? string() : draft_message->input_message_text_.text.text,
             std::move(input_message_entities), std::move(media), message_effect_id),
         {{dialog_id}}));
diff --git a/td/telegram/GameManager.cpp b/td/telegram/GameManager.cpp
index 76beb0e34..134c03b88 100644
--- a/td/telegram/GameManager.cpp
+++ b/td/telegram/GameManager.cpp
@@ -35,14 +35,6 @@ class SetGameScoreQuery final : public Td::ResultHandler {
 
   void send(DialogId dialog_id, MessageId message_id, bool edit_message,
             tl_object_ptr<telegram_api::InputUser> input_user, int32 score, bool force) {
-    int32 flags = 0;
-    if (edit_message) {
-      flags |= telegram_api::messages_setGameScore::EDIT_MESSAGE_MASK;
-    }
-    if (force) {
-      flags |= telegram_api::messages_setGameScore::FORCE_MASK;
-    }
-
     dialog_id_ = dialog_id;
 
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Edit);
@@ -52,7 +44,7 @@ class SetGameScoreQuery final : public Td::ResultHandler {
 
     CHECK(input_user != nullptr);
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_setGameScore(flags, false /*ignored*/, false /*ignored*/, std::move(input_peer),
+        telegram_api::messages_setGameScore(0, edit_message, force, std::move(input_peer),
                                             message_id.get_server_message_id().get(), std::move(input_user), score),
         {{dialog_id}}));
   }
diff --git a/td/telegram/InlineMessageManager.cpp b/td/telegram/InlineMessageManager.cpp
index 37851bc78..fb6254ed2 100644
--- a/td/telegram/InlineMessageManager.cpp
+++ b/td/telegram/InlineMessageManager.cpp
@@ -95,9 +95,6 @@ class EditInlineMessageQuery final : public Td::ResultHandler {
     CHECK(!FileManager::extract_was_uploaded(input_media));
 
     int32 flags = 0;
-    if (disable_web_page_preview) {
-      flags |= telegram_api::messages_editInlineBotMessage::NO_WEBPAGE_MASK;
-    }
     if (reply_markup != nullptr) {
       flags |= telegram_api::messages_editInlineBotMessage::REPLY_MARKUP_MASK;
     }
@@ -110,14 +107,11 @@ class EditInlineMessageQuery final : public Td::ResultHandler {
     if (input_media != nullptr) {
       flags |= telegram_api::messages_editInlineBotMessage::MEDIA_MASK;
     }
-    if (invert_media) {
-      flags |= telegram_api::messages_editInlineBotMessage::INVERT_MEDIA_MASK;
-    }
 
     auto dc_id = DcId::internal(get_inline_message_dc_id(input_bot_inline_message_id));
     send_query(G()->net_query_creator().create(
         telegram_api::messages_editInlineBotMessage(
-            flags, false /*ignored*/, false /*ignored*/, std::move(input_bot_inline_message_id), text,
+            flags, disable_web_page_preview, invert_media, std::move(input_bot_inline_message_id), text,
             std::move(input_media), std::move(reply_markup), std::move(entities)),
         {}, dc_id));
   }
@@ -151,18 +145,10 @@ class SetInlineGameScoreQuery final : public Td::ResultHandler {
     CHECK(input_bot_inline_message_id != nullptr);
     CHECK(input_user != nullptr);
 
-    int32 flags = 0;
-    if (edit_message) {
-      flags |= telegram_api::messages_setInlineGameScore::EDIT_MESSAGE_MASK;
-    }
-    if (force) {
-      flags |= telegram_api::messages_setInlineGameScore::FORCE_MASK;
-    }
-
     auto dc_id = DcId::internal(get_inline_message_dc_id(input_bot_inline_message_id));
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_setInlineGameScore(flags, false /*ignored*/, false /*ignored*/,
-                                                  std::move(input_bot_inline_message_id), std::move(input_user), score),
+        telegram_api::messages_setInlineGameScore(0, edit_message, force, std::move(input_bot_inline_message_id),
+                                                  std::move(input_user), score),
         {}, dc_id));
   }
 
diff --git a/td/telegram/InlineQueriesManager.cpp b/td/telegram/InlineQueriesManager.cpp
index e6a5bcb4a..3fed1f102 100644
--- a/td/telegram/InlineQueriesManager.cpp
+++ b/td/telegram/InlineQueriesManager.cpp
@@ -131,12 +131,6 @@ class SetInlineBotResultsQuery final : public Td::ResultHandler {
             vector<tl_object_ptr<telegram_api::InputBotInlineResult>> &&results, int32 cache_time,
             const string &next_offset) {
     int32 flags = 0;
-    if (is_gallery) {
-      flags |= telegram_api::messages_setInlineBotResults::GALLERY_MASK;
-    }
-    if (is_personal) {
-      flags |= telegram_api::messages_setInlineBotResults::PRIVATE_MASK;
-    }
     if (!next_offset.empty()) {
       flags |= telegram_api::messages_setInlineBotResults::NEXT_OFFSET_MASK;
     }
@@ -147,7 +141,7 @@ class SetInlineBotResultsQuery final : public Td::ResultHandler {
       flags |= telegram_api::messages_setInlineBotResults::SWITCH_WEBVIEW_MASK;
     }
     send_query(G()->net_query_creator().create(telegram_api::messages_setInlineBotResults(
-        flags, false /*ignored*/, false /*ignored*/, inline_query_id, std::move(results), cache_time, next_offset,
+        flags, is_gallery, is_personal, inline_query_id, std::move(results), cache_time, next_offset,
         std::move(switch_pm), std::move(web_view))));
   }
 
@@ -254,6 +248,8 @@ class RequestSimpleWebViewQuery final : public Td::ResultHandler {
       flags |= telegram_api::messages_requestSimpleWebView::THEME_PARAMS_MASK;
     }
     string start_parameter;
+    bool from_switch_webview = false;
+    bool from_side_menu = false;
     if (ends_with(url, "#kb")) {
       // a URL from keyboard button
       url.resize(url.size() - 3);
@@ -261,28 +257,22 @@ class RequestSimpleWebViewQuery final : public Td::ResultHandler {
     } else if (ends_with(url, "#iq")) {
       // a URL from inline query results button
       url.resize(url.size() - 3);
-      flags |= telegram_api::messages_requestSimpleWebView::FROM_SWITCH_WEBVIEW_MASK;
+      from_switch_webview = true;
       flags |= telegram_api::messages_requestSimpleWebView::URL_MASK;
     } else if (url.empty()) {
-      flags |= telegram_api::messages_requestSimpleWebView::FROM_SIDE_MENU_MASK;
+      from_side_menu = true;
     } else if (begins_with(url, "start://")) {
       start_parameter = url.substr(8);
       url = string();
 
-      flags |= telegram_api::messages_requestSimpleWebView::FROM_SIDE_MENU_MASK;
+      from_side_menu = true;
       flags |= telegram_api::messages_requestSimpleWebView::START_PARAM_MASK;
     } else {
       return on_error(Status::Error(400, "Invalid URL specified"));
     }
-    if (parameters.is_compact()) {
-      flags |= telegram_api::messages_requestSimpleWebView::COMPACT_MASK;
-    }
-    if (parameters.is_full_screen()) {
-      flags |= telegram_api::messages_requestSimpleWebView::FULLSCREEN_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_requestSimpleWebView(
-        flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_user), url,
-        start_parameter, std::move(theme_parameters), parameters.get_application_name())));
+        flags, from_switch_webview, from_side_menu, parameters.is_compact(), parameters.is_full_screen(),
+        std::move(input_user), url, start_parameter, std::move(theme_parameters), parameters.get_application_name())));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/LinkManager.cpp b/td/telegram/LinkManager.cpp
index c78b1a938..2bd02e3ec 100644
--- a/td/telegram/LinkManager.cpp
+++ b/td/telegram/LinkManager.cpp
@@ -1109,7 +1109,7 @@ class AcceptUrlAuthQuery final : public Td::ResultHandler {
   void send(string url, MessageFullId message_full_id, int32 button_id, bool allow_write_access) {
     url_ = std::move(url);
     int32 flags = 0;
-    tl_object_ptr<telegram_api::InputPeer> input_peer;
+    telegram_api::object_ptr<telegram_api::InputPeer> input_peer;
     if (message_full_id.get_dialog_id().is_valid()) {
       dialog_id_ = message_full_id.get_dialog_id();
       input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
@@ -1118,12 +1118,9 @@ class AcceptUrlAuthQuery final : public Td::ResultHandler {
     } else {
       flags |= telegram_api::messages_acceptUrlAuth::URL_MASK;
     }
-    if (allow_write_access) {
-      flags |= telegram_api::messages_acceptUrlAuth::WRITE_ALLOWED_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_acceptUrlAuth(
-        flags, false /*ignored*/, std::move(input_peer), message_full_id.get_message_id().get_server_message_id().get(),
-        button_id, url_)));
+        flags, allow_write_access, std::move(input_peer),
+        message_full_id.get_message_id().get_server_message_id().get(), button_id, url_)));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/MessageReaction.cpp b/td/telegram/MessageReaction.cpp
index 48e6428d1..0f05d1d65 100644
--- a/td/telegram/MessageReaction.cpp
+++ b/td/telegram/MessageReaction.cpp
@@ -61,18 +61,10 @@ class SendReactionQuery final : public Td::ResultHandler {
     int32 flags = 0;
     if (!reaction_types.empty()) {
       flags |= telegram_api::messages_sendReaction::REACTION_MASK;
-
-      if (is_big) {
-        flags |= telegram_api::messages_sendReaction::BIG_MASK;
-      }
-
-      if (add_to_recent) {
-        flags |= telegram_api::messages_sendReaction::ADD_TO_RECENT_MASK;
-      }
     }
 
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_sendReaction(flags, false /*ignored*/, false /*ignored*/, std::move(input_peer),
+        telegram_api::messages_sendReaction(flags, is_big, add_to_recent, std::move(input_peer),
                                             message_full_id.get_message_id().get_server_message_id().get(),
                                             ReactionType::get_input_reactions(reaction_types)),
         {{dialog_id_}, {message_full_id}}));
diff --git a/td/telegram/Payments.cpp b/td/telegram/Payments.cpp
index 74283ba3e..ca582d8f4 100644
--- a/td/telegram/Payments.cpp
+++ b/td/telegram/Payments.cpp
@@ -253,14 +253,15 @@ class SetBotPreCheckoutAnswerQuery final : public Td::ResultHandler {
 
   void send(int64 pre_checkout_query_id, const string &error_message) {
     int32 flags = 0;
+    bool is_success = false;
     if (!error_message.empty()) {
       flags |= telegram_api::messages_setBotPrecheckoutResults::ERROR_MASK;
     } else {
-      flags |= telegram_api::messages_setBotPrecheckoutResults::SUCCESS_MASK;
+      is_success = true;
     }
 
-    send_query(G()->net_query_creator().create(telegram_api::messages_setBotPrecheckoutResults(
-        flags, false /*ignored*/, pre_checkout_query_id, error_message)));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_setBotPrecheckoutResults(flags, is_success, pre_checkout_query_id, error_message)));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/SavedMessagesManager.cpp b/td/telegram/SavedMessagesManager.cpp
index a991fc79f..fc7ddbe28 100644
--- a/td/telegram/SavedMessagesManager.cpp
+++ b/td/telegram/SavedMessagesManager.cpp
@@ -74,10 +74,8 @@ class GetSavedDialogsQuery final : public Td::ResultHandler {
     auto input_peer = DialogManager::get_input_peer_force(offset_dialog_id);
     CHECK(input_peer != nullptr);
 
-    int32 flags = telegram_api::messages_getSavedDialogs::EXCLUDE_PINNED_MASK;
     send_query(G()->net_query_creator().create(telegram_api::messages_getSavedDialogs(
-        flags, false /*ignored*/, offset_date, offset_message_id.get_server_message_id().get(), std::move(input_peer),
-        limit, 0)));
+        0, true, offset_date, offset_message_id.get_server_message_id().get(), std::move(input_peer), limit, 0)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -251,12 +249,8 @@ class ToggleSavedDialogPinQuery final : public Td::ResultHandler {
     auto saved_input_peer = saved_messages_topic_id.get_input_dialog_peer(td_);
     CHECK(saved_input_peer != nullptr);
 
-    int32 flags = 0;
-    if (is_pinned) {
-      flags |= telegram_api::messages_toggleSavedDialogPin::PINNED_MASK;
-    }
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_toggleSavedDialogPin(flags, false /*ignored*/, std::move(saved_input_peer))));
+        telegram_api::messages_toggleSavedDialogPin(0, is_pinned, std::move(saved_input_peer))));
   }
 
   void on_result(BufferSlice packet) final {
@@ -287,9 +281,8 @@ class ReorderPinnedSavedDialogsQuery final : public Td::ResultHandler {
       CHECK(saved_input_peer != nullptr);
       return saved_input_peer;
     });
-    int32 flags = telegram_api::messages_reorderPinnedSavedDialogs::FORCE_MASK;
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_reorderPinnedSavedDialogs(flags, true /*ignored*/, std::move(order))));
+    send_query(
+        G()->net_query_creator().create(telegram_api::messages_reorderPinnedSavedDialogs(0, true, std::move(order))));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/SecretChatActor.cpp b/td/telegram/SecretChatActor.cpp
index 871bf8acb..66abe3ea2 100644
--- a/td/telegram/SecretChatActor.cpp
+++ b/td/telegram/SecretChatActor.cpp
@@ -705,12 +705,8 @@ void SecretChatActor::do_close_chat_impl(bool delete_history, bool is_already_di
   send_update_secret_chat();
 
   if (!is_already_discarded) {
-    int32 flags = 0;
-    if (delete_history) {
-      flags |= telegram_api::messages_discardEncryption::DELETE_HISTORY_MASK;
-    }
     auto query = create_net_query(QueryType::DiscardEncryption,
-                                  telegram_api::messages_discardEncryption(flags, false /*ignored*/, auth_state_.id));
+                                  telegram_api::messages_discardEncryption(0, delete_history, auth_state_.id));
     query->total_timeout_limit_ = 60 * 60 * 24 * 365;
     context_->send_net_query(std::move(query), actor_shared(this), true);
     discard_encryption_promise_ = mpas.get_promise();
@@ -1240,7 +1236,7 @@ Status SecretChatActor::do_inbound_message_decrypted(unique_ptr<log_event::Inbou
     auto old = move_tl_object_as<secret_api::decryptedMessage46>(message->decrypted_message_layer->message_);
     old->flags_ &= ~secret_api::decryptedMessage::GROUPED_ID_MASK;  // just in case
     message->decrypted_message_layer->message_ = secret_api::make_object<secret_api::decryptedMessage>(
-        old->flags_, false /*ignored*/, old->random_id_, old->ttl_, std::move(old->message_), std::move(old->media_),
+        old->flags_, false, old->random_id_, old->ttl_, std::move(old->message_), std::move(old->media_),
         std::move(old->entities_), std::move(old->via_bot_name_), old->reply_to_random_id_, 0);
   }
   if (message->decrypted_message_layer->message_->get_id() == secret_api::decryptedMessageService8::ID) {
diff --git a/td/telegram/SponsoredMessageManager.cpp b/td/telegram/SponsoredMessageManager.cpp
index 9010e2600..ab1a8a59c 100644
--- a/td/telegram/SponsoredMessageManager.cpp
+++ b/td/telegram/SponsoredMessageManager.cpp
@@ -92,15 +92,8 @@ class ClickSponsoredMessageQuery final : public Td::ResultHandler {
   }
 
   void send(const string &message_id, bool is_media_click, bool from_fullscreen) {
-    int32 flags = 0;
-    if (is_media_click) {
-      flags |= telegram_api::messages_clickSponsoredMessage::MEDIA_MASK;
-    }
-    if (from_fullscreen) {
-      flags |= telegram_api::messages_clickSponsoredMessage::FULLSCREEN_MASK;
-    }
-    send_query(G()->net_query_creator().create(telegram_api::messages_clickSponsoredMessage(
-        flags, false /*ignored*/, false /*ignored*/, BufferSlice(message_id))));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_clickSponsoredMessage(0, is_media_click, from_fullscreen, BufferSlice(message_id))));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/td/telegram/StickersManager.cpp b/td/telegram/StickersManager.cpp
index f8b2a0d12..17724278a 100644
--- a/td/telegram/StickersManager.cpp
+++ b/td/telegram/StickersManager.cpp
@@ -126,12 +126,9 @@ class SearchStickersQuery final : public Td::ResultHandler {
     parameters_ = std::move(parameters);
     sticker_type_ = sticker_type;
     is_first_ = offset == 0;
-    int32 flags = 0;
-    if (sticker_type == StickerType::CustomEmoji) {
-      flags |= telegram_api::messages_searchStickers::EMOJIS_MASK;
-    }
-    send_query(G()->net_query_creator().create(telegram_api::messages_searchStickers(
-        flags, false /*ignored*/, query, emoji, std::move(input_language_codes), offset, limit, hash)));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_searchStickers(0, sticker_type == StickerType::CustomEmoji, query, emoji,
+                                              std::move(input_language_codes), offset, limit, hash)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -329,15 +326,9 @@ class GetArchivedStickerSetsQuery final : public Td::ResultHandler {
     offset_sticker_set_id_ = offset_sticker_set_id;
     sticker_type_ = sticker_type;
 
-    int32 flags = 0;
-    if (sticker_type_ == StickerType::Mask) {
-      flags |= telegram_api::messages_getArchivedStickers::MASKS_MASK;
-    }
-    if (sticker_type_ == StickerType::CustomEmoji) {
-      flags |= telegram_api::messages_getArchivedStickers::EMOJIS_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_getArchivedStickers(
-        flags, false /*ignored*/, false /*ignored*/, offset_sticker_set_id.get(), limit)));
+        0, sticker_type == StickerType::Mask, sticker_type == StickerType::CustomEmoji, offset_sticker_set_id.get(),
+        limit)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -485,13 +476,7 @@ class GetRecentStickersQuery final : public Td::ResultHandler {
   void send(bool is_repair, bool is_attached, int64 hash) {
     is_repair_ = is_repair;
     is_attached_ = is_attached;
-    int32 flags = 0;
-    if (is_attached) {
-      flags |= telegram_api::messages_getRecentStickers::ATTACHED_MASK;
-    }
-
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_getRecentStickers(flags, is_attached /*ignored*/, hash)));
+    send_query(G()->net_query_creator().create(telegram_api::messages_getRecentStickers(0, is_attached, hash)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -533,14 +518,8 @@ class SaveRecentStickerQuery final : public Td::ResultHandler {
     file_reference_ = input_document->file_reference_.as_slice().str();
     unsave_ = unsave;
     is_attached_ = is_attached;
-
-    int32 flags = 0;
-    if (is_attached) {
-      flags |= telegram_api::messages_saveRecentSticker::ATTACHED_MASK;
-    }
-
     send_query(G()->net_query_creator().create(
-        telegram_api::messages_saveRecentSticker(flags, is_attached /*ignored*/, std::move(input_document), unsave)));
+        telegram_api::messages_saveRecentSticker(0, is_attached, std::move(input_document), unsave)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -593,14 +572,7 @@ class ClearRecentStickersQuery final : public Td::ResultHandler {
 
   void send(bool is_attached) {
     is_attached_ = is_attached;
-
-    int32 flags = 0;
-    if (is_attached) {
-      flags |= telegram_api::messages_clearRecentStickers::ATTACHED_MASK;
-    }
-
-    send_query(
-        G()->net_query_creator().create(telegram_api::messages_clearRecentStickers(flags, is_attached /*ignored*/)));
+    send_query(G()->net_query_creator().create(telegram_api::messages_clearRecentStickers(0, is_attached)));
   }
 
   void on_result(BufferSlice packet) final {
@@ -721,15 +693,9 @@ class ReorderStickerSetsQuery final : public Td::ResultHandler {
  public:
   void send(StickerType sticker_type, const vector<StickerSetId> &sticker_set_ids) {
     sticker_type_ = sticker_type;
-    int32 flags = 0;
-    if (sticker_type == StickerType::Mask) {
-      flags |= telegram_api::messages_reorderStickerSets::MASKS_MASK;
-    }
-    if (sticker_type == StickerType::CustomEmoji) {
-      flags |= telegram_api::messages_reorderStickerSets::EMOJIS_MASK;
-    }
     send_query(G()->net_query_creator().create(telegram_api::messages_reorderStickerSets(
-        flags, false /*ignored*/, false /*ignored*/, StickersManager::convert_sticker_set_ids(sticker_set_ids))));
+        0, sticker_type == StickerType::Mask, sticker_type == StickerType::CustomEmoji,
+        StickersManager::convert_sticker_set_ids(sticker_set_ids))));
   }
 
   void on_result(BufferSlice packet) final {
@@ -880,12 +846,10 @@ class SearchStickerSetsQuery final : public Td::ResultHandler {
     query_ = std::move(query);
     switch (sticker_type) {
       case StickerType::Regular:
-        send_query(
-            G()->net_query_creator().create(telegram_api::messages_searchStickerSets(0, false /*ignored*/, query_, 0)));
+        send_query(G()->net_query_creator().create(telegram_api::messages_searchStickerSets(0, false, query_, 0)));
         break;
       case StickerType::CustomEmoji:
-        send_query(G()->net_query_creator().create(
-            telegram_api::messages_searchEmojiStickerSets(0, false /*ignored*/, query_, 0)));
+        send_query(G()->net_query_creator().create(telegram_api::messages_searchEmojiStickerSets(0, false, query_, 0)));
         break;
       default:
         UNREACHABLE();
diff --git a/td/telegram/WebAppManager.cpp b/td/telegram/WebAppManager.cpp
index 0ab73c3e5..fc8b4c9a5 100644
--- a/td/telegram/WebAppManager.cpp
+++ b/td/telegram/WebAppManager.cpp
@@ -111,25 +111,16 @@ class RequestAppWebViewQuery final : public Td::ResultHandler {
     if (theme_parameters != nullptr) {
       flags |= telegram_api::messages_requestAppWebView::THEME_PARAMS_MASK;
     }
-    if (allow_write_access) {
-      flags |= telegram_api::messages_requestAppWebView::WRITE_ALLOWED_MASK;
-    }
     if (!start_parameter.empty()) {
       flags |= telegram_api::messages_requestAppWebView::START_PARAM_MASK;
     }
-    if (parameters.is_compact()) {
-      flags |= telegram_api::messages_requestAppWebView::COMPACT_MASK;
-    }
-    if (parameters.is_full_screen()) {
-      flags |= telegram_api::messages_requestAppWebView::FULLSCREEN_MASK;
-    }
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     CHECK(input_peer != nullptr);
     auto input_bot_app =
         telegram_api::make_object<telegram_api::inputBotAppShortName>(std::move(input_user), web_app_short_name);
     send_query(G()->net_query_creator().create(telegram_api::messages_requestAppWebView(
-        flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_peer), std::move(input_bot_app),
-        start_parameter, std::move(theme_parameters), parameters.get_application_name())));
+        flags, allow_write_access, parameters.is_compact(), parameters.is_full_screen(), std::move(input_peer),
+        std::move(input_bot_app), start_parameter, std::move(theme_parameters), parameters.get_application_name())));
   }
 
   void on_result(BufferSlice packet) final {
@@ -160,6 +151,8 @@ class RequestMainWebViewQuery final : public Td::ResultHandler {
 
   void send(DialogId dialog_id, telegram_api::object_ptr<telegram_api::InputUser> &&input_user,
             const string &start_parameter, const WebAppOpenParameters &parameters) {
+    is_full_screen_ = parameters.is_full_screen();
+
     int32 flags = 0;
     auto theme_parameters = parameters.get_input_theme_parameters();
     if (theme_parameters != nullptr) {
@@ -168,17 +161,10 @@ class RequestMainWebViewQuery final : public Td::ResultHandler {
     if (!start_parameter.empty()) {
       flags |= telegram_api::messages_requestMainWebView::START_PARAM_MASK;
     }
-    if (parameters.is_compact()) {
-      flags |= telegram_api::messages_requestMainWebView::COMPACT_MASK;
-    }
-    if (parameters.is_full_screen()) {
-      is_full_screen_ = true;
-      flags |= telegram_api::messages_requestMainWebView::FULLSCREEN_MASK;
-    }
     auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id, AccessRights::Read);
     CHECK(input_peer != nullptr);
     send_query(G()->net_query_creator().create(telegram_api::messages_requestMainWebView(
-        flags, false /*ignored*/, false /*ignored*/, std::move(input_peer), std::move(input_user), start_parameter,
+        flags, parameters.is_compact(), is_full_screen_, std::move(input_peer), std::move(input_user), start_parameter,
         std::move(theme_parameters), parameters.get_application_name())));
   }
 
@@ -236,6 +222,7 @@ class RequestWebViewQuery final : public Td::ResultHandler {
     CHECK(input_peer != nullptr);
 
     string start_parameter;
+    bool from_bot_menu = false;
     if (begins_with(url, "start://")) {
       start_parameter = url.substr(8);
       url = string();
@@ -244,7 +231,7 @@ class RequestWebViewQuery final : public Td::ResultHandler {
     } else if (begins_with(url, "menu://")) {
       url = url.substr(7);
 
-      flags |= telegram_api::messages_requestWebView::FROM_BOT_MENU_MASK;
+      from_bot_menu = true;
       flags |= telegram_api::messages_requestWebView::URL_MASK;
     } else if (!url.empty()) {
       flags |= telegram_api::messages_requestWebView::URL_MASK;
@@ -262,11 +249,7 @@ class RequestWebViewQuery final : public Td::ResultHandler {
       flags |= telegram_api::messages_requestWebView::REPLY_TO_MASK;
     }
 
-    if (silent) {
-      flags |= telegram_api::messages_requestWebView::SILENT_MASK;
-    }
-
-    tl_object_ptr<telegram_api::InputPeer> as_input_peer;
+    telegram_api::object_ptr<telegram_api::InputPeer> as_input_peer;
     if (as_dialog_id.is_valid()) {
       as_input_peer = td_->dialog_manager_->get_input_peer(as_dialog_id, AccessRights::Write);
       if (as_input_peer != nullptr) {
@@ -274,15 +257,8 @@ class RequestWebViewQuery final : public Td::ResultHandler {
       }
     }
 
-    if (parameters.is_compact()) {
-      flags |= telegram_api::messages_requestWebView::COMPACT_MASK;
-    }
-    if (parameters.is_full_screen()) {
-      flags |= telegram_api::messages_requestWebView::FULLSCREEN_MASK;
-    }
-
     send_query(G()->net_query_creator().create(telegram_api::messages_requestWebView(
-        flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_peer),
+        flags, from_bot_menu, silent, parameters.is_compact(), parameters.is_full_screen(), std::move(input_peer),
         std::move(input_user), url, start_parameter, std::move(theme_parameters), parameters.get_application_name(),
         std::move(reply_to), std::move(as_input_peer))));
   }
@@ -329,11 +305,8 @@ class ProlongWebViewQuery final : public Td::ResultHandler {
     if (reply_to != nullptr) {
       flags |= telegram_api::messages_prolongWebView::REPLY_TO_MASK;
     }
-    if (silent) {
-      flags |= telegram_api::messages_prolongWebView::SILENT_MASK;
-    }
 
-    tl_object_ptr<telegram_api::InputPeer> as_input_peer;
+    telegram_api::object_ptr<telegram_api::InputPeer> as_input_peer;
     if (as_dialog_id.is_valid()) {
       as_input_peer = td_->dialog_manager_->get_input_peer(as_dialog_id, AccessRights::Write);
       if (as_input_peer != nullptr) {
@@ -341,9 +314,9 @@ class ProlongWebViewQuery final : public Td::ResultHandler {
       }
     }
 
-    send_query(G()->net_query_creator().create(telegram_api::messages_prolongWebView(
-        flags, false /*ignored*/, std::move(input_peer), r_input_user.move_as_ok(), query_id, std::move(reply_to),
-        std::move(as_input_peer))));
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_prolongWebView(flags, silent, std::move(input_peer), r_input_user.move_as_ok(), query_id,
+                                              std::move(reply_to), std::move(as_input_peer))));
   }
 
   void on_result(BufferSlice packet) final {
diff --git a/test/secret.cpp b/test/secret.cpp
index 22f6e53de..9405f0ebc 100644
--- a/test/secret.cpp
+++ b/test/secret.cpp
@@ -890,8 +890,8 @@ class Master final : public Actor {
     LOG(INFO) << "Send message: " << tag("id", id) << tag("text", text) << tag("random_id", random_id);
     sent_messages_[random_id] = Message{id, text};
     send_closure(get_by_id(id), &SecretChatProxy::send_message,
-                 secret_api::make_object<secret_api::decryptedMessage>(0, false /*ignored*/, random_id, 0, text, Auto(),
-                                                                       Auto(), Auto(), Auto(), 0));
+                 secret_api::make_object<secret_api::decryptedMessage>(0, false, random_id, 0, text, Auto(), Auto(),
+                                                                       Auto(), Auto(), 0));
   }
   void process_net_query(my_api::messages_sendEncryptedService &&message, NetQueryPtr net_query,
                          ActorShared<NetQueryCallback> callback) {