@mtkruto/node 0.68.0 → 0.70.0

package/esm/client/5_client.js

@@ -21,12 +21,14 @@ import { delay, MINUTE, SECOND, unreachable } from "../0_deps.js";
 import { AccessError, ConnectionError, InputError } from "../0_errors.js";
 import { cleanObject, drop, getLogger, mustPrompt, mustPromptOneOf, Mutex, ZERO_CHANNEL_ID } from "../1_utilities.js";
 import { StorageMemory } from "../2_storage.js";
-import { Api, Mtproto } from "../2_tl.js";
+import { Api, Mtproto, toJSON } from "../2_tl.js";
 import { getDcId } from "../3_transport.js";
-import { constructUser } from "../3_types.js";
+import { constructChatP, constructUser2 } from "../3_types.js";
 import { APP_VERSION, DEVICE_MODEL, INITIAL_DC, LANG_CODE, LANG_PACK, MAX_CHANNEL_ID, MAX_CHAT_ID, SYSTEM_LANG_CODE, SYSTEM_VERSION, USERNAME_TTL } from "../4_constants.js";
 import { AuthKeyUnregistered, FloodWait, Migrate, PasswordHashInvalid, PhoneNumberInvalid, SessionPasswordNeeded, SessionRevoked } from "../4_errors.js";
 import { PhoneCodeInvalid } from "../4_errors.js";
+import { peerToChatId } from "../tl/2_telegram.js";
+import { AbortableLoop } from "./0_abortable_loop.js";
 import { checkPassword } from "./0_password.js";
 import { StorageOperations } from "./0_storage_operations.js";
 import { canBeInputChannel, canBeInputUser, DOWNLOAD_POOL_SIZE, getUsername, resolve, toInputChannel, toInputUser } from "./0_utilities.js";
@@ -62,7 +64,8 @@ export const restartAuth = Symbol("restartAuth");
 export const handleMigrationError = Symbol("handleMigrationError");
 // global Client ID counter for logs
 let id = 0;
-const getEntity = Symbol();
+const getPeer = Symbol();
+const mustGetPeer = Symbol();
 /**
  * An MTKruto client.
  */
@@ -147,6 +150,7 @@ export class Client extends Composer {
     #L;
     #LsignIn;
     #LupdateGapRecoveryLoop;
+    #LstorageWriteLoop;
     #LhandleMigrationError;
     #Lmin;
     /**
@@ -186,6 +190,7 @@ export class Client extends Composer {
         const L = this.#L = getLogger("Client").client(id++);
         this.#LsignIn = L.branch("signIn");
         this.#LupdateGapRecoveryLoop = L.branch("updateGapRecoveryLoop");
+        this.#LstorageWriteLoop = L.branch("storageWriteLoop");
         this.#LhandleMigrationError = L.branch("[handleMigrationError]");
         this.#Lmin = L.branch("min");
         const c = {
@@ -213,7 +218,7 @@ export class Client extends Composer {
             getInputChannel: this.getInputChannel.bind(this),
             getInputUser: this.getInputUser.bind(this),
             getInputPeerChatId: this.#getInputPeerChatId.bind(this),
-            getEntity: this[getEntity].bind(this),
+            getPeer: this[mustGetPeer].bind(this),
             handleUpdate: this.#queueHandleCtxUpdate.bind(this),
             parseMode: this.#parseMode,
             outgoingMessages: this.#outgoingMessages,
@@ -312,22 +317,21 @@ export class Client extends Composer {
         return this.#client?.disconnected ?? true;
     }
     #constructContext = async (update) => {
-        const msg = "message" in update ? update.message : "editedMessage" in update ? update.editedMessage : "scheduledMessage" in update ? update.scheduledMessage : "callbackQuery" in update ? update.callbackQuery.message : undefined;
-        const reactions = "messageInteractions" in update ? update.messageInteractions : undefined;
-        const mustGetMsg = () => {
-            if (msg !== undefined) {
-                return { chatId: msg.chat.id, messageId: msg.id, businessConnectionId: msg.businessConnectionId, senderId: msg.from?.id, userId: msg.from?.id };
+        const mustGetMsg = (ctx) => {
+            if (ctx.msg !== undefined) {
+                return { chatId: ctx.msg.chat.id, messageId: ctx.msg.id, businessConnectionId: ctx.msg.businessConnectionId, senderId: ctx.msg.from?.id, userId: ctx.msg.from?.id };
             }
-            else if (reactions !== undefined) {
+            const reactions = "messageInteractions" in update ? update.messageInteractions : undefined;
+            if (reactions !== undefined) {
                 return { chatId: reactions.chatId, messageId: reactions.messageId };
             }
             else {
                 unreachable();
             }
         };
-        const mustGetUserId = () => {
-            if (msg?.from) {
-                return msg.from.id;
+        const mustGetUserId = (ctx) => {
+            if (ctx.msg?.from) {
+                return ctx.msg.from.id;
             }
             else if ("callbackQuery" in update) {
                 return update.callbackQuery.from.id;
@@ -352,9 +356,6 @@ export class Client extends Composer {
             }
             unreachable();
         };
-        const chat_ = "messageReactions" in update ? update.messageReactions.chat : "messageReactionCount" in update ? update.messageReactionCount.chat : "chatMember" in update ? update.chatMember.chat : "myChatMember" in update ? update.myChatMember.chat : "joinRequest" in update ? update.joinRequest.chat : "story" in update ? update.story.chat : undefined;
-        const chat = chat_ ?? msg?.chat;
-        const from = "callbackQuery" in update ? update.callbackQuery.from : "inlineQuery" in update ? update.inlineQuery.from : "chatMember" in update ? update.chatMember.from : "myChatMember" in update ? update.myChatMember.from : "messageReactions" in update ? update.messageReactions.user : "preCheckoutQuery" in update ? update.preCheckoutQuery.from : "joinRequest" in update ? update.joinRequest.from : "businessConnection" in update ? update.businessConnection.user : "pollAnswer" in update ? update.pollAnswer.from : msg?.from ? msg.from : undefined;
         const getReplyTo = (quote, chatId, messageId) => {
             if ("story" in update) {
                 return { chatId: update.story.chat.id, storyId: update.story.id };
@@ -363,350 +364,368 @@ export class Client extends Composer {
             const shouldQuote = quote === undefined ? !isPrivate : quote;
             return shouldQuote ? { messageId } : undefined;
         };
-        const me = "connectionState" in update ? this.#lastGetMe : ("authorizationState" in update && !update.authorizationState.authorized) ? this.#lastGetMe : await this.#getMe();
+        if (this.#lastGetMe === null && !("connectionState" in update) && (!("authorizationState" in update) || ("authorizationState" in update && update.authorizationState.authorized))) {
+            await this.#getMe();
+        }
         const context = {
             ...update,
             client: this,
-            me: (me == null ? undefined : me),
-            msg: msg,
-            chat: chat,
-            from: from,
-            get toJSON() {
-                return () => update;
-            },
-            reply: (text, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            get me() {
+                return this.client.#lastGetMe === null ? undefined : this.client.#lastGetMe;
+            },
+            get msg() {
+                return "message" in update ? update.message : "editedMessage" in update ? update.editedMessage : "scheduledMessage" in update ? update.scheduledMessage : "callbackQuery" in update ? update.callbackQuery.message : undefined;
+            },
+            get chat() {
+                return this.msg?.chat ?? ("messageReactions" in update ? update.messageReactions.chat : "messageReactionCount" in update ? update.messageReactionCount.chat : "chatMember" in update ? update.chatMember.chat : "myChatMember" in update ? update.myChatMember.chat : "joinRequest" in update ? update.joinRequest.chat : "story" in update ? update.story.chat : undefined);
+            },
+            get from() {
+                const from = "callbackQuery" in update ? update.callbackQuery.from : "inlineQuery" in update ? update.inlineQuery.from : "chatMember" in update ? update.chatMember.from : "myChatMember" in update ? update.myChatMember.from : "messageReactions" in update ? update.messageReactions.user : "preCheckoutQuery" in update ? update.preCheckoutQuery.from : "joinRequest" in update ? update.joinRequest.from : "businessConnection" in update ? update.businessConnection.user : "pollAnswer" in update ? update.pollAnswer.from : this.msg?.from;
+                return from;
+            },
+            toJSON() {
+                if ("update" in update) {
+                    return { update: toJSON(update.update) };
+                }
+                else {
+                    return update;
+                }
+            },
+            reply(text, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendMessage(chatId, text, { ...params, replyTo, businessConnectionId });
+                return this.client.sendMessage(chatId, text, { ...params, replyTo, businessConnectionId });
             },
-            replyPoll: (question, options, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyPoll(question, options, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendPoll(chatId, question, options, { ...params, replyTo, businessConnectionId });
+                return this.client.sendPoll(chatId, question, options, { ...params, replyTo, businessConnectionId });
             },
-            replyPhoto: (photo, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyPhoto(photo, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendPhoto(chatId, photo, { ...params, replyTo, businessConnectionId });
+                return this.client.sendPhoto(chatId, photo, { ...params, replyTo, businessConnectionId });
             },
-            replyMediaGroup: (media, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyMediaGroup(media, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendMediaGroup(chatId, media, { ...params, replyTo, businessConnectionId });
+                return this.client.sendMediaGroup(chatId, media, { ...params, replyTo, businessConnectionId });
             },
-            replyInvoice: (title, description, payload, currency, prices, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyInvoice(title, description, payload, currency, prices, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendInvoice(chatId, title, description, payload, currency, prices, { ...params, replyTo, businessConnectionId });
+                return this.client.sendInvoice(chatId, title, description, payload, currency, prices, { ...params, replyTo, businessConnectionId });
             },
-            replyDocument: (document, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyDocument(document, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendDocument(chatId, document, { ...params, replyTo, businessConnectionId });
+                return this.client.sendDocument(chatId, document, { ...params, replyTo, businessConnectionId });
             },
-            replySticker: (sticker, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replySticker(sticker, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendSticker(chatId, sticker, { ...params, replyTo, businessConnectionId });
+                return this.client.sendSticker(chatId, sticker, { ...params, replyTo, businessConnectionId });
             },
-            replyContact: (firstName, number, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyContact(firstName, number, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendContact(chatId, firstName, number, { ...params, replyTo, businessConnectionId });
+                return this.client.sendContact(chatId, firstName, number, { ...params, replyTo, businessConnectionId });
             },
-            replyLocation: (latitude, longitude, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyLocation(latitude, longitude, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendLocation(chatId, latitude, longitude, { ...params, replyTo, businessConnectionId });
+                return this.client.sendLocation(chatId, latitude, longitude, { ...params, replyTo, businessConnectionId });
             },
-            replyDice: (params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyDice(params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendDice(chatId, { ...params, replyTo, businessConnectionId });
+                return this.client.sendDice(chatId, { ...params, replyTo, businessConnectionId });
             },
-            replyVenue: (latitude, longitude, title, address, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyVenue(latitude, longitude, title, address, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendVenue(chatId, latitude, longitude, title, address, { ...params, replyTo, businessConnectionId });
+                return this.client.sendVenue(chatId, latitude, longitude, title, address, { ...params, replyTo, businessConnectionId });
             },
-            replyVideo: (video, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyVideo(video, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendVideo(chatId, video, { ...params, replyTo, businessConnectionId });
+                return this.client.sendVideo(chatId, video, { ...params, replyTo, businessConnectionId });
             },
-            replyAnimation: (document, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyAnimation(document, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendAnimation(chatId, document, { ...params, replyTo, businessConnectionId });
+                return this.client.sendAnimation(chatId, document, { ...params, replyTo, businessConnectionId });
             },
-            replyVoice: (document, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyVoice(document, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendVoice(chatId, document, { ...params, replyTo, businessConnectionId });
+                return this.client.sendVoice(chatId, document, { ...params, replyTo, businessConnectionId });
             },
-            replyAudio: (document, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyAudio(document, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendAudio(chatId, document, { ...params, replyTo, businessConnectionId });
+                return this.client.sendAudio(chatId, document, { ...params, replyTo, businessConnectionId });
             },
-            replyVideoNote: (videoNote, params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
+            replyVideoNote(videoNote, params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
                 const replyTo = getReplyTo(params?.quote, chatId, messageId);
-                return this.sendVideoNote(chatId, videoNote, { ...params, replyTo, businessConnectionId });
+                return this.client.sendVideoNote(chatId, videoNote, { ...params, replyTo, businessConnectionId });
             },
-            delete: () => {
-                const { chatId, messageId } = mustGetMsg();
-                return this.deleteMessage(chatId, messageId);
+            delete() {
+                const { chatId, messageId } = mustGetMsg(this);
+                return this.client.deleteMessage(chatId, messageId);
             },
-            forward: (to, params) => {
-                const { chatId, messageId } = mustGetMsg();
-                return this.forwardMessage(chatId, to, messageId, params);
+            forward(to, params) {
+                const { chatId, messageId } = mustGetMsg(this);
+                return this.client.forwardMessage(chatId, to, messageId, params);
             },
-            pin: (params) => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
-                return this.pinMessage(chatId, messageId, { ...params, businessConnectionId });
+            pin(params) {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
+                return this.client.pinMessage(chatId, messageId, { ...params, businessConnectionId });
             },
-            unpin: () => {
-                const { chatId, messageId, businessConnectionId } = mustGetMsg();
-                return this.unpinMessage(chatId, messageId, { businessConnectionId });
+            unpin() {
+                const { chatId, messageId, businessConnectionId } = mustGetMsg(this);
+                return this.client.unpinMessage(chatId, messageId, { businessConnectionId });
             },
-            banSender: (params) => {
-                const { chatId, senderId } = mustGetMsg();
+            banSender(params) {
+                const { chatId, senderId } = mustGetMsg(this);
                 if (!senderId) {
                     unreachable();
                 }
-                return this.banChatMember(chatId, senderId, params);
+                return this.client.banChatMember(chatId, senderId, params);
             },
-            kickSender: () => {
-                const { chatId, senderId } = mustGetMsg();
+            kickSender() {
+                const { chatId, senderId } = mustGetMsg(this);
                 if (!senderId) {
                     unreachable();
                 }
-                return this.kickChatMember(chatId, senderId);
+                return this.client.kickChatMember(chatId, senderId);
             },
-            setSenderRights: (params) => {
-                const { chatId, senderId } = mustGetMsg();
+            setSenderRights(params) {
+                const { chatId, senderId } = mustGetMsg(this);
                 if (!senderId) {
                     unreachable();
                 }
-                return this.setChatMemberRights(chatId, senderId, params);
+                return this.client.setChatMemberRights(chatId, senderId, params);
             },
-            getChatAdministrators: () => {
-                const { chatId } = mustGetMsg();
-                return this.getChatAdministrators(chatId);
+            getChatAdministrators() {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getChatAdministrators(chatId);
             },
-            react: (reactions, params) => {
-                const { chatId, messageId } = mustGetMsg();
-                return this.setReactions(chatId, messageId, reactions, params);
+            react(reactions, params) {
+                const { chatId, messageId } = mustGetMsg(this);
+                return this.client.setReactions(chatId, messageId, reactions, params);
             },
-            answerCallbackQuery: (params) => {
+            answerCallbackQuery(params) {
                 if (!("callbackQuery" in update)) {
                     unreachable();
                 }
-                return this.answerCallbackQuery(update.callbackQuery.id, params);
+                return this.client.answerCallbackQuery(update.callbackQuery.id, params);
             },
-            answerInlineQuery: (results, params) => {
+            answerInlineQuery(results, params) {
                 if (!("inlineQuery" in update)) {
                     unreachable();
                 }
-                return this.answerInlineQuery(update.inlineQuery.id, results, params);
+                return this.client.answerInlineQuery(update.inlineQuery.id, results, params);
             },
-            sendChatAction: (chatAction, params) => {
-                const { chatId } = mustGetMsg();
-                return this.sendChatAction(chatId, chatAction, params);
+            sendChatAction(chatAction, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.sendChatAction(chatId, chatAction, params);
             },
-            editInlineMessageText: (text, params) => {
+            editInlineMessageText(text, params) {
                 const inlineMessageId = mustGetInlineMsgId();
-                return this.editInlineMessageText(inlineMessageId, text, params);
+                return this.client.editInlineMessageText(inlineMessageId, text, params);
             },
-            editInlineMessageMedia: (media, params) => {
+            editInlineMessageMedia(media, params) {
                 const inlineMessageId = mustGetInlineMsgId();
-                return this.editInlineMessageMedia(inlineMessageId, media, params);
+                return this.client.editInlineMessageMedia(inlineMessageId, media, params);
             },
-            editInlineMessageCaption: (params) => {
+            editInlineMessageCaption(params) {
                 const inlineMessageId = mustGetInlineMsgId();
-                return this.editInlineMessageCaption(inlineMessageId, params);
+                return this.client.editInlineMessageCaption(inlineMessageId, params);
             },
-            editInlineMessageLiveLocation: (latitude, longitude, params) => {
+            editInlineMessageLiveLocation(latitude, longitude, params) {
                 const inlineMessageId = mustGetInlineMsgId();
-                return this.editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params);
+                return this.client.editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params);
             },
-            editInlineMessageReplyMarkup: (params) => {
+            editInlineMessageReplyMarkup(params) {
                 const inlineMessageId = mustGetInlineMsgId();
-                return this.editInlineMessageReplyMarkup(inlineMessageId, params);
+                return this.client.editInlineMessageReplyMarkup(inlineMessageId, params);
             },
-            editMessageText: (messageId, text, params) => {
-                const { chatId } = mustGetMsg();
-                return this.editMessageText(chatId, messageId, text, params);
+            editMessageText(messageId, text, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.editMessageText(chatId, messageId, text, params);
             },
-            editMessageCaption: (messageId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.editMessageCaption(chatId, messageId, params);
+            editMessageCaption(messageId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.editMessageCaption(chatId, messageId, params);
             },
-            editMessageMedia: (messageId, media, params) => {
-                const { chatId } = mustGetMsg();
-                return this.editMessageMedia(chatId, messageId, media, params);
+            editMessageMedia(messageId, media, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.editMessageMedia(chatId, messageId, media, params);
             },
-            editMessageLiveLocation: (messageId, latitude, longitude, params) => {
-                const { chatId } = mustGetMsg();
-                return this.editMessageLiveLocation(chatId, messageId, latitude, longitude, params);
+            editMessageLiveLocation(messageId, latitude, longitude, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.editMessageLiveLocation(chatId, messageId, latitude, longitude, params);
             },
-            editMessageReplyMarkup: (messageId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.editMessageReplyMarkup(chatId, messageId, params);
+            editMessageReplyMarkup(messageId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.editMessageReplyMarkup(chatId, messageId, params);
             },
-            getMessage: (messageId) => {
-                const { chatId } = mustGetMsg();
-                return this.getMessage(chatId, messageId);
+            getMessage(messageId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getMessage(chatId, messageId);
             },
-            getMessages: (messageIds) => {
-                const { chatId } = mustGetMsg();
-                return this.getMessages(chatId, messageIds);
+            getMessages(messageIds) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getMessages(chatId, messageIds);
             },
-            forwardMessage: (to, messageId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.forwardMessage(chatId, to, messageId, params);
+            forwardMessage(to, messageId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.forwardMessage(chatId, to, messageId, params);
             },
-            forwardMessages: (to, messageIds, params) => {
-                const { chatId } = mustGetMsg();
-                return this.forwardMessages(chatId, to, messageIds, params);
+            forwardMessages(to, messageIds, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.forwardMessages(chatId, to, messageIds, params);
             },
-            deleteMessage: (messageId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.deleteMessage(chatId, messageId, params);
+            deleteMessage(messageId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.deleteMessage(chatId, messageId, params);
             },
-            deleteMessages: (messageIds, params) => {
-                const { chatId } = mustGetMsg();
-                return this.deleteMessages(chatId, messageIds, params);
+            deleteMessages(messageIds, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.deleteMessages(chatId, messageIds, params);
             },
-            pinMessage: (messageId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.pinMessage(chatId, messageId, params);
+            pinMessage(messageId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.pinMessage(chatId, messageId, params);
             },
-            unpinMessage: (messageId) => {
-                const { chatId } = mustGetMsg();
-                return this.unpinMessage(chatId, messageId);
+            unpinMessage(messageId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.unpinMessage(chatId, messageId);
             },
-            unpinMessages: () => {
-                const { chatId } = mustGetMsg();
-                return this.unpinMessages(chatId);
+            unpinMessages() {
+                const { chatId } = mustGetMsg(this);
+                return this.client.unpinMessages(chatId);
             },
-            setAvailableReactions: (availableReactions) => {
-                const { chatId } = mustGetMsg();
-                return this.setAvailableReactions(chatId, availableReactions);
+            setAvailableReactions(availableReactions) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setAvailableReactions(chatId, availableReactions);
             },
-            addReaction: (messageId, reaction, params) => {
-                const { chatId } = mustGetMsg();
-                return this.addReaction(chatId, messageId, reaction, params);
+            addReaction(messageId, reaction, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.addReaction(chatId, messageId, reaction, params);
             },
-            removeReaction: (messageId, reaction) => {
-                const { chatId } = mustGetMsg();
-                return this.removeReaction(chatId, messageId, reaction);
+            removeReaction(messageId, reaction) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.removeReaction(chatId, messageId, reaction);
             },
-            setReactions: (messageId, reactions, params) => {
-                const { chatId } = mustGetMsg();
-                return this.setReactions(chatId, messageId, reactions, params);
+            setReactions(messageId, reactions, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setReactions(chatId, messageId, reactions, params);
             },
-            read: () => {
-                const { chatId, messageId } = mustGetMsg();
-                return this.readMessages(chatId, messageId);
+            read() {
+                const { chatId, messageId } = mustGetMsg(this);
+                return this.client.readMessages(chatId, messageId);
             },
-            setChatPhoto: (photo, params) => {
-                const { chatId } = mustGetMsg();
-                return this.setChatPhoto(chatId, photo, params);
+            setChatPhoto(photo, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setChatPhoto(chatId, photo, params);
             },
-            deleteChatPhoto: () => {
-                const { chatId } = mustGetMsg();
-                return this.deleteChatPhoto(chatId);
+            deleteChatPhoto() {
+                const { chatId } = mustGetMsg(this);
+                return this.client.deleteChatPhoto(chatId);
             },
-            banChatMember: (memberId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.banChatMember(chatId, memberId, params);
+            banChatMember(memberId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.banChatMember(chatId, memberId, params);
             },
-            unbanChatMember: (memberId) => {
-                const { chatId } = mustGetMsg();
-                return this.unbanChatMember(chatId, memberId);
+            unbanChatMember(memberId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.unbanChatMember(chatId, memberId);
             },
-            kickChatMember: (memberId) => {
-                const { chatId } = mustGetMsg();
-                return this.kickChatMember(chatId, memberId);
+            kickChatMember(memberId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.kickChatMember(chatId, memberId);
             },
-            setChatMemberRights: (memberId, params) => {
-                const { chatId } = mustGetMsg();
-                return this.setChatMemberRights(chatId, memberId, params);
+            setChatMemberRights(memberId, params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setChatMemberRights(chatId, memberId, params);
             },
-            deleteChatMemberMessages: (userId) => {
-                const { chatId } = mustGetMsg();
-                return this.deleteChatMemberMessages(chatId, userId);
+            deleteChatMemberMessages(userId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.deleteChatMemberMessages(chatId, userId);
             },
-            searchMessages: (query, params) => {
-                const { chatId } = mustGetMsg();
-                return this.searchMessages(chatId, query, params);
+            searchMessages(params) {
+                const { chatId } = mustGetMsg(this);
+                params ??= {};
+                params.chatId = chatId;
+                return this.client.searchMessages(params);
             },
-            setBoostsRequiredToCircumventRestrictions: (boosts) => {
-                const { chatId } = mustGetMsg();
-                return this.setBoostsRequiredToCircumventRestrictions(chatId, boosts);
+            setBoostsRequiredToCircumventRestrictions(boosts) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setBoostsRequiredToCircumventRestrictions(chatId, boosts);
             },
-            createInviteLink: (params) => {
-                const { chatId } = mustGetMsg();
-                return this.createInviteLink(chatId, params);
+            createInviteLink(params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.createInviteLink(chatId, params);
             },
-            getCreatedInviteLinks: (params) => {
-                const { chatId } = mustGetMsg();
-                return this.getCreatedInviteLinks(chatId, params);
+            getCreatedInviteLinks(params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getCreatedInviteLinks(chatId, params);
             },
-            leave: () => {
-                const { chatId } = mustGetMsg();
-                return this.leaveChat(chatId);
+            leave() {
+                const { chatId } = mustGetMsg(this);
+                return this.client.leaveChat(chatId);
             },
-            block: () => {
-                return this.blockUser(mustGetUserId());
+            block() {
+                return this.client.blockUser(mustGetUserId(this));
             },
-            unblock: () => {
-                return this.unblockUser(mustGetUserId());
+            unblock() {
+                return this.client.unblockUser(mustGetUserId(this));
             },
-            getChatMember: (userId) => {
-                const { chatId } = mustGetMsg();
-                return this.getChatMember(chatId, userId);
+            getChatMember(userId) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getChatMember(chatId, userId);
             },
-            getChatMembers: (params) => {
-                const { chatId } = mustGetMsg();
-                return this.getChatMembers(chatId, params);
+            getChatMembers(params) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.getChatMembers(chatId, params);
             },
-            setChatStickerSet: (setName) => {
-                const { chatId } = mustGetMsg();
-                return this.setChatStickerSet(chatId, setName);
+            setChatStickerSet(setName) {
+                const { chatId } = mustGetMsg(this);
+                return this.client.setChatStickerSet(chatId, setName);
             },
-            deleteChatStickerSet: () => {
-                const { chatId } = mustGetMsg();
-                return this.deleteChatStickerSet(chatId);
+            deleteChatStickerSet() {
+                const { chatId } = mustGetMsg(this);
+                return this.client.deleteChatStickerSet(chatId);
             },
-            getBusinessConnection: () => {
-                const { businessConnectionId } = mustGetMsg();
+            getBusinessConnection() {
+                const { businessConnectionId } = mustGetMsg(this);
                 if (!businessConnectionId) {
                     unreachable();
                 }
-                return this.getBusinessConnection(businessConnectionId);
+                return this.client.getBusinessConnection(businessConnectionId);
             },
-            answerPreCheckoutQuery: (ok, params) => {
+            answerPreCheckoutQuery(ok, params) {
                 if (!("preCheckoutQuery" in update)) {
                     unreachable();
                 }
-                return this.answerPreCheckoutQuery(update.preCheckoutQuery.id, ok, params);
+                return this.client.answerPreCheckoutQuery(update.preCheckoutQuery.id, ok, params);
             },
-            approveJoinRequest: () => {
-                const { chatId, userId } = mustGetMsg();
+            approveJoinRequest() {
+                const { chatId, userId } = mustGetMsg(this);
                 if (!userId) {
                     unreachable();
                 }
-                return this.approveJoinRequest(chatId, userId);
+                return this.client.approveJoinRequest(chatId, userId);
             },
-            declineJoinRequest: () => {
-                const { chatId, userId } = mustGetMsg();
+            declineJoinRequest() {
+                const { chatId, userId } = mustGetMsg(this);
                 if (!userId) {
                     unreachable();
                 }
-                return this.declineJoinRequest(chatId, userId);
+                return this.client.declineJoinRequest(chatId, userId);
             },
         };
         return cleanObject(context);
@@ -718,7 +737,7 @@ export class Client extends Composer {
     #lastPropagatedConnectionState = null;
     #stateChangeHandler = ((connected) => {
         const connectionState = connected ? "ready" : "notConnected";
-        if (this.#lastPropagatedConnectionState != connectionState) {
+        if (this.#lastPropagatedConnectionState !== connectionState) {
             this.#propagateConnectionState(connectionState);
         }
     }).bind(this);
@@ -728,6 +747,7 @@ export class Client extends Composer {
             await this.storage.initialize();
             if (!this.#guaranteeUpdateDelivery) {
                 await this.storage.deleteUpdates();
+                await this.storage.commit(true);
             }
             this.#storageInited = true;
         }
@@ -748,28 +768,39 @@ export class Client extends Composer {
             if (this.#authString && !this.#authStringImported) {
                 await this.importAuthString(this.#authString);
             }
-            const [authKey, dc] = await Promise.all([this.storage.getAuthKey(), this.storage.getDc()]);
-            if (authKey != null && dc != null) {
-                if (!this.#client || this.#client.dc != dc) {
+            const auth = this.storage.auth.mustGet();
+            if (auth.authKey !== null && auth.dc !== null) {
+                if (!this.#client || this.#client.dc !== auth.dc) {
                     this.#client?.disconnect();
-                    this.#setMainClient(this.#newClient(dc, true, false));
+                    this.#setMainClient(this.#newClient(auth.dc, true, false));
                 }
-                await this.#client.setAuthKey(authKey);
-                if (this.#client.serverSalt == 0n) {
+                await this.#client.setAuthKey(auth.authKey);
+                if (this.#client.serverSalt === 0n) {
                     this.#client.serverSalt = await this.storage.getServerSalt() ?? 0n;
                 }
             }
             else {
-                const dc = await this.storage.getDc() ?? this.#initialDc;
-                if (!this.#client || this.#client.dc != dc) {
+                const dc = auth.dc ?? this.#initialDc;
+                if (!this.#client || this.#client.dc !== dc) {
                     this.#client?.disconnect();
                     this.#setMainClient(this.#newClient(dc, true, false));
                 }
             }
             await this.#client.connect();
-            await Promise.all([this.storage.setAuthKey(this.#client.authKey), this.storage.setDc(this.#client.dc), this.storage.setServerSalt(this.#client.serverSalt)]);
-            this.#startUpdateGapRecoveryLoop();
-            this.#startClientDisconnectionLoop();
+            await this.storage.auth.update((v) => {
+                v.authKey = this.#client.authKey;
+                v.dc = this.#client.dc;
+            });
+            await this.storage.setServerSalt(this.#client.serverSalt);
+            this.#updateGapRecoveryLoop.start();
+            this.#clientDisconnectionLoop.start();
+            if (!this.#messageStorage_.isMemory) {
+                this.#storageWriteLoop.start();
+            }
+            else {
+                this.#L.debug("not starting storageWriteLoop");
+            }
+            await this.storage.commit(true);
         }
         finally {
             unlock();
@@ -781,101 +812,87 @@ export class Client extends Composer {
             newDc += "-test";
         }
         this.disconnect();
-        await this.storage.setDc(newDc);
-        await this.storage.setAuthKey(null);
+        await this.storage.auth.update((v) => {
+            v.authKey = null;
+            v.dc = newDc;
+        });
         await this.connect();
         this.#LhandleMigrationError.debug(`migrated to DC${newDc}`);
     }
-    disconnect() {
+    async disconnect() {
         this.#disconnectAllClients();
-        this.#clientDisconnectionLoopAbortController?.abort();
-        this.#updateGapRecoveryLoopAbortController?.abort();
+        this.#clientDisconnectionLoop.abort();
+        this.#updateGapRecoveryLoop.abort();
+        this.#storageWriteLoop.abort();
         this.#updateManager.closeAllChats();
+        await this.messageStorage.commit(true);
     }
     #lastPropagatedAuthorizationState = null;
     async #propagateAuthorizationState(authorized) {
-        if (this.#lastPropagatedAuthorizationState != authorized) {
+        if (this.#lastPropagatedAuthorizationState !== authorized) {
             await this.#handleCtxUpdate({ authorizationState: { authorized } });
             this.#lastPropagatedAuthorizationState = authorized;
         }
     }
     async #getSelfId() {
         const id = await this.storage.getAccountId();
-        if (id == null) {
+        if (id === null) {
             throw new Error("Unauthorized");
         }
         return id;
     }
     async #getIsPremium() {
         const maybeIsPremium = await this.storage.getIsPremium();
-        if (maybeIsPremium != null) {
+        if (maybeIsPremium !== null) {
             return maybeIsPremium;
         }
         return this.#lastGetMe?.isPremium ?? false;
     }
     #lastUpdates = new Date();
-    #updateGapRecoveryLoopAbortController;
-    #startUpdateGapRecoveryLoop() {
-        drop(this.#updateGapRecoveryLoop());
-    }
-    async #updateGapRecoveryLoop() {
-        this.#updateGapRecoveryLoopAbortController?.abort();
-        const controller = this.#updateGapRecoveryLoopAbortController = new AbortController();
-        while (this.connected) {
-            try {
-                await delay(60 * SECOND, { signal: controller.signal });
-                if (!this.connected) {
-                    break;
-                }
-                controller.signal.throwIfAborted();
-                if (Date.now() - this.#lastUpdates.getTime() >= 15 * MINUTE) {
-                    drop(this.#updateManager.recoverUpdateGap("lastUpdates").then(() => {
-                        this.#lastUpdates = new Date();
-                    }));
-                }
-            }
-            catch (err) {
-                if (err instanceof DOMException && err.name == "AbortError") {
-                    break;
-                }
-                else if (!this.connected) {
-                    break;
-                }
-                this.#LupdateGapRecoveryLoop.error(err);
-            }
+    #updateGapRecoveryLoop = new AbortableLoop(async (signal) => {
+        await delay(60 * SECOND, { signal });
+        if (!this.connected) {
+            this.#updateGapRecoveryLoop.abort();
+            return;
         }
-    }
-    #clientDisconnectionLoopAbortController;
-    #startClientDisconnectionLoop() {
-        drop(this.#clientDisconnectionLoop());
-    }
-    async #clientDisconnectionLoop() {
-        const controller = this.#clientDisconnectionLoopAbortController = new AbortController();
-        while (this.connected) {
-            try {
-                await delay(60 * SECOND, { signal: controller.signal });
-                if (!this.connected) {
-                    break;
-                }
-                controller.signal.throwIfAborted();
-                const now = Date.now();
-                const disconnectAfter = 5 * MINUTE;
-                this.#clients.map((client, i) => {
-                    if (i > 0 && !client.disconnected && client.lastRequest && now - client.lastRequest.getTime() >= disconnectAfter) {
-                        client?.disconnect();
-                    }
-                });
-            }
-            catch (err) {
-                if (err instanceof DOMException && err.name == "AbortError") {
-                    break;
-                }
-                else if (!this.connected) {
-                    break;
-                }
+        if (Date.now() - this.#lastUpdates.getTime() >= 15 * MINUTE) {
+            drop(this.#updateManager.recoverUpdateGap("lastUpdates").then(() => {
+                this.#lastUpdates = new Date();
+            }));
+        }
+    }, (err) => {
+        if (!this.connected) {
+            this.#updateGapRecoveryLoop.abort();
+        }
+        else {
+            this.#LupdateGapRecoveryLoop.error(err);
+        }
+    });
+    #clientDisconnectionLoop = new AbortableLoop(async (signal) => {
+        await delay(60 * SECOND, { signal });
+        if (!this.connected) {
+            this.#clientDisconnectionLoop.abort();
+            return;
+        }
+        const now = Date.now();
+        const disconnectAfter = 5 * MINUTE;
+        for (const [i, client] of this.#clients.entries()) {
+            if (i > 0 && !client.disconnected && client.lastRequest && now - client.lastRequest.getTime() >= disconnectAfter) {
+                client?.disconnect();
             }
         }
-    }
+    }, () => {
+        if (!this.connected) {
+            this.#clientDisconnectionLoop.abort();
+        }
+    });
+    #storageWriteLoop = new AbortableLoop(async (signal) => {
+        await delay(60 * SECOND, { signal });
+        await this.messageStorage.commit();
+        await this.storage.commit();
+    }, (err) => {
+        this.#LstorageWriteLoop.error(err);
+    });
     /**
      * Signs in using the provided parameters if not already signed in.
      * If no parameters are provided, the credentials will be prompted in runtime.
@@ -905,7 +922,7 @@ export class Client extends Composer {
         }
         if (typeof params === "undefined") {
             const loginType = mustPromptOneOf("Do you want to login as bot [b] or user [u]?", ["b", "u"]);
-            if (loginType == "b") {
+            if (loginType === "b") {
                 params = { botToken: mustPrompt("Bot token:") };
             }
             else {
@@ -917,8 +934,11 @@ export class Client extends Composer {
             while (true) {
                 try {
                     const auth = await this.invoke({ _: "auth.importBotAuthorization", api_id: this.#apiId, api_hash: this.#apiHash, bot_auth_token: params.botToken, flags: 0 });
-                    await this.storage.setAccountId(Number(Api.as("auth.authorization", auth).user.id));
-                    await this.storage.setAccountType("bot");
+                    await this.storage.auth.update((v) => {
+                        v.userId = Number(Api.as("auth.authorization", auth).user.id);
+                        v.isBot = true;
+                    });
+                    await this.storage.commit(true);
                     break;
                 }
                 catch (err) {
@@ -984,8 +1004,10 @@ export class Client extends Composer {
                             phone_code: code,
                             phone_code_hash: sentCode.phone_code_hash,
                         });
-                        await this.storage.setAccountId(Number(Api.as("auth.authorization", auth).user.id));
-                        await this.storage.setAccountType("user");
+                        await this.storage.auth.update((v) => {
+                            v.userId = Number(Api.as("auth.authorization", auth).user.id);
+                            v.isBot = false;
+                        });
                         this.#LsignIn.debug("signed in as user");
                         await this.#propagateAuthorizationState(true);
                         await this.#updateManager.fetchState("signIn");
@@ -1013,8 +1035,11 @@ export class Client extends Composer {
                         const password = typeof params.password === "string" ? params.password : await params.password(ap.hint ?? null);
                         const input = await checkPassword(password, ap);
                         const auth = await this.invoke({ _: "auth.checkPassword", password: input });
-                        await this.storage.setAccountId(Number(Api.as("auth.authorization", auth).user.id));
-                        await this.storage.setAccountType("user");
+                        await this.storage.auth.update((v) => {
+                            v.userId = Number(Api.as("auth.authorization", auth).user.id);
+                            v.isBot = false;
+                        });
+                        await this.storage.commit(true);
                         this.#LsignIn.debug("signed in as user");
                         await this.#propagateAuthorizationState(true);
                         await this.#updateManager.fetchState("signIn");
@@ -1031,7 +1056,7 @@ export class Client extends Composer {
                 }
             }
             catch (err) {
-                if (err == restartAuth) {
+                if (err === restartAuth) {
                     continue auth;
                 }
                 else {
@@ -1082,15 +1107,15 @@ export class Client extends Composer {
     }
     #getMainClientMutex = new Mutex();
     async #getMainClient(dc) {
-        if (dc === undefined || dc == this.#client?.dc) {
+        if (dc === undefined || dc === this.#client?.dc) {
             return this.#client;
         }
-        let client = this.#clients.find((v) => v.dc == dc);
+        let client = this.#clients.find((v) => v.dc === dc);
         if (client) {
             return client;
         }
         const unlock = await this.#getMainClientMutex.lock();
-        client = this.#clients.find((v) => v.dc == dc);
+        client = this.#clients.find((v) => v.dc === dc);
         if (client) {
             return client;
         }
@@ -1123,7 +1148,7 @@ export class Client extends Composer {
     }
     async #getUploadPoolSize() {
         const dc = this.#client.dc;
-        return (dc != "2" && dc != "4") || await this.#getIsPremium() ? 8 : 4;
+        return (dc !== "2" && dc !== "4") || await this.#getIsPremium() ? 8 : 4;
     }
     async #getUploadClient() {
         const dc = this.#client.dc;
@@ -1142,19 +1167,21 @@ export class Client extends Composer {
         return client;
     }
     async #setupClient(client) {
-        const storage = client.dc == this.#client.dc ? this.storage : new StorageOperations(this.storage.provider.branch(client.dc + (client.cdn ? "_cdn" : "")));
-        const [authKey, serverSalt] = await Promise.all([storage.getAuthKey(), storage.getServerSalt()]);
-        if (authKey) {
-            await client.setAuthKey(authKey);
+        const storage = client.dc === this.#client.dc ? this.storage : new StorageOperations(this.storage.provider.branch(client.dc + (client.cdn ? "_cdn" : "")));
+        await storage.initialize();
+        const auth = storage.auth.mustGet();
+        const serverSalt = await storage.getServerSalt();
+        if (auth.authKey !== null) {
+            await client.setAuthKey(auth.authKey);
             if (serverSalt) {
                 client.serverSalt = serverSalt;
             }
         }
         await client.connect();
-        if (!authKey) {
+        if (auth.authKey === null) {
             await this.#importAuthorization(client);
         }
-        await storage.setAuthKey(client.authKey);
+        await storage.auth.update((v) => v.authKey = client.authKey);
         if (client.dc !== this.#client.dc) {
             await storage.setServerSalt(client.serverSalt);
             client.handlers.onNewServerSalt = async (serverSalt) => {
@@ -1163,10 +1190,11 @@ export class Client extends Composer {
         }
     }
     async #importAuthorization(client) {
-        if (this.#client.dc == client.dc && this.#client.cdn == client.cdn) {
-            const [authKey, serverSalt] = await Promise.all([this.storage.getAuthKey(), this.storage.getServerSalt()]);
-            if (authKey) {
-                await client.setAuthKey(authKey);
+        if (this.#client.dc === client.dc && this.#client.cdn === client.cdn) {
+            const auth = this.storage.auth.mustGet();
+            const serverSalt = await this.storage.getServerSalt();
+            if (auth.authKey !== null) {
+                await client.setAuthKey(auth.authKey);
                 if (serverSalt) {
                     client.serverSalt = serverSalt;
                 }
@@ -1232,7 +1260,7 @@ export class Client extends Composer {
             this.#handleInvokeError = async (ctx, next) => {
                 let result = null;
                 return await handle(ctx, async () => {
-                    if (result != null)
+                    if (result !== null)
                         return result;
                     result = await handler(ctx, next);
                     return result;
@@ -1252,23 +1280,17 @@ export class Client extends Composer {
         await this.storage.importAuthString(authString);
         this.#authStringImported = true;
         if (!this.#apiId) {
-            this.#apiId = await this.storage.getApiId() ?? 0;
+            this.#apiId = this.storage.auth.mustGet().apiId;
         }
     }
     async #getUserAccessHash(userId) {
         const users = await this.invoke({ _: "users.getUsers", id: [{ _: "inputUser", user_id: userId, access_hash: 0n }] });
         const user = Api.is("user", users[0]) ? users[0] : undefined;
-        if (user) {
-            await this.messageStorage.setEntity(user);
-        }
         return user?.access_hash ?? 0n;
     }
     async #getChannelAccessHash(channelId) {
         const channels = await this.invoke({ _: "channels.getChannels", id: [{ _: "inputChannel", channel_id: channelId, access_hash: 0n }] });
         const channel = Api.is("channel", channels.chats[0]) ? channels.chats[0] : undefined;
-        if (channel) {
-            await this.messageStorage.setEntity(channel);
-        }
         return channel?.access_hash ?? 0n;
     }
     /**
@@ -1277,11 +1299,11 @@ export class Client extends Composer {
      * @param id The identifier of a chat.
      */
     async getInputPeer(id) {
-        if (id === "me" || id == await this.#getSelfId()) {
+        if (id === "me" || id === await this.#getSelfId()) {
             return { _: "inputPeerSelf" };
         }
         const inputPeer = await this.#getInputPeerInner(id);
-        if (((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash == 0n) && await this.storage.getAccountType() == "bot") {
+        if (((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash === 0n) && this.storage.isBot) {
             if ("channel_id" in inputPeer) {
                 inputPeer.access_hash = await this.#getChannelAccessHash(inputPeer.channel_id);
             }
@@ -1289,7 +1311,7 @@ export class Client extends Composer {
                 inputPeer.access_hash = await this.#getUserAccessHash(inputPeer.user_id);
             }
         }
-        if ((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash == 0n) {
+        if ((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash === 0n) {
             throw new AccessError(`Cannot access the chat ${id} because there is no access hash for it.`);
         }
         return inputPeer;
@@ -1338,8 +1360,8 @@ export class Client extends Composer {
         if (typeof id === "string") {
             id = getUsername(id);
             let resolvedId = 0;
-            const maybeUsername = await this.messageStorage.getUsername(id);
-            if (maybeUsername != null && Date.now() - maybeUsername[1].getTime() < USERNAME_TTL) {
+            const maybeUsername = await this.messageStorage.usernames.get([id]);
+            if (maybeUsername !== null && Date.now() - maybeUsername[1].getTime() < USERNAME_TTL) {
                 const [id] = maybeUsername;
                 resolvedId = id;
             }
@@ -1358,11 +1380,11 @@ export class Client extends Composer {
                 }
             }
             const resolvedIdType = Api.getChatIdPeerType(resolvedId);
-            if (resolvedIdType == "user") {
+            if (resolvedIdType === "user") {
                 const accessHash = await this.messageStorage.getUserAccessHash(resolvedId);
                 peer = { _: "inputPeerUser", user_id: Api.chatIdToPeerId(resolvedId), access_hash: accessHash ?? 0n };
             }
-            else if (resolvedIdType == "channel") {
+            else if (resolvedIdType === "channel") {
                 const accessHash = await this.messageStorage.getChannelAccessHash(resolvedId);
                 peer = { _: "inputPeerChannel", channel_id: Api.chatIdToPeerId(resolvedId), access_hash: accessHash ?? 0n };
             }
@@ -1377,7 +1399,7 @@ export class Client extends Composer {
         else if (-MAX_CHAT_ID <= id) {
             peer = { _: "inputPeerChat", chat_id: BigInt(Math.abs(id)) };
         }
-        else if (ZERO_CHANNEL_ID - MAX_CHANNEL_ID <= id && id != ZERO_CHANNEL_ID) {
+        else if (ZERO_CHANNEL_ID - MAX_CHANNEL_ID <= id && id !== ZERO_CHANNEL_ID) {
             const accessHash = await this.messageStorage.getChannelAccessHash(id);
             peer = { _: "inputPeerChannel", channel_id: Api.chatIdToPeerId(id), access_hash: accessHash ?? 0n };
         }
@@ -1385,23 +1407,24 @@ export class Client extends Composer {
             throw new InputError("The ID is of an format unknown.");
         }
         if (!Api.is("inputPeerChat", peer) && !peer.access_hash) {
-            const chatId = Api.peerToChatId(peer);
-            const minPeerReference = await this.messageStorage.getLastMinPeerReference(chatId);
-            if (minPeerReference) {
-                const minInputPeer = await this.#getMinInputPeer(canBeInputChannel(peer) ? "channel" : "user", { ...minPeerReference, senderId: chatId });
-                if (minInputPeer) {
-                    this.#Lmin.debug("resolved input min peer", minInputPeer);
-                    peer = minInputPeer;
-                }
-            }
+            // TODO
+            // const chatId = Api.peerToChatId(peer);
+            // const minPeerReference = await this.messageStorage.getLastMinPeerReference(chatId);
+            // if (minPeerReference) {
+            //   const minInputPeer = await this.#getMinInputPeer(canBeInputChannel(peer) ? "channel" : "user", { ...minPeerReference, senderId: chatId });
+            //   if (minInputPeer) {
+            //     this.#Lmin.debug("resolved input min peer", minInputPeer);
+            //     peer = minInputPeer;
+            //   }
+            // }
         }
         return peer;
     }
     async #getMinInputPeer(type, reference) {
-        const entity = await this.messageStorage.getEntity(reference.chatId);
-        if (Api.isOneOf(["channel", "channelForbidden"], entity) && entity.access_hash) {
-            const peer = { _: "inputPeerChannel", channel_id: entity.id, access_hash: entity.access_hash };
-            if (type == "user") {
+        const peer_ = await this.messageStorage.peers.get([reference.chatId]);
+        if (peer_ !== null && (peer_[0].type === "channel" || peer_[0].type === "supergroup")) {
+            const peer = { _: "inputPeerChannel", channel_id: BigInt(peer_[0].id), access_hash: peer_[1] };
+            if (type === "user") {
                 return { _: "inputPeerUserFromMessage", peer, msg_id: reference.messageId, user_id: Api.chatIdToPeerId(reference.senderId) };
             }
             else {
@@ -1412,16 +1435,19 @@ export class Client extends Composer {
             return null;
         }
     }
-    async [getEntity](peer) {
+    async [getPeer](peer) {
         const id = Api.peerToChatId(peer);
-        const entity = await this.messageStorage.getEntity(id);
-        if (entity == null && await this.storage.getAccountType() == "bot" && Api.is("peerUser", peer) || Api.is("peerChannel", peer)) {
+        const entity = await this.messageStorage.peers.get([id]);
+        if (entity === null && this.storage.isBot && Api.is("peerUser", peer) || Api.is("peerChannel", peer)) {
             await this.getInputPeer(id);
         }
         else {
             return entity;
         }
-        return await this.messageStorage.getEntity(id);
+        return await this.messageStorage.peers.get([id]);
+    }
+    [mustGetPeer](peer) {
+        return this.messageStorage.peers.mustGet([peerToChatId(peer)]);
     }
     async #handleCtxUpdate(update) {
         if (this.#disableUpdates && !("authorizationState" in update) && !("connectionState" in update)) {
@@ -1441,65 +1467,81 @@ export class Client extends Composer {
         });
     }
     async #handleUpdate(update) {
-        const promises = new Array();
+        const maybePromises = new Array();
         if (Api.is("updateUserName", update)) {
-            await this.messageStorage.updateUsernames(Number(update.user_id), update.usernames.map((v) => v.username));
+            const value = [Number(update.user_id), new Date()];
+            for (const username_ of update.usernames) {
+                const username = username_.username.toLowerCase();
+                this.messageStorage.usernames.set([username], value);
+            }
             const peer = { ...update, _: "peerUser" };
-            const entity = await this[getEntity](peer);
-            if (entity != null) {
-                entity.usernames = update.usernames;
-                entity.first_name = update.first_name;
-                entity.last_name = update.last_name;
-                await this.messageStorage.setEntity(entity);
+            const peer_ = await this[getPeer](peer);
+            if (peer_ !== null) {
+                const username = update.usernames[0];
+                if (username !== undefined) {
+                    peer_[0].username = username.username;
+                    const also = update.usernames.filter((v) => v !== username);
+                    if (also.length) {
+                        peer_[0].also = also.map((v) => v.username);
+                    }
+                    else {
+                        delete peer_[0].also;
+                    }
+                }
+                else {
+                    delete peer_[0].username;
+                }
+                this.messageStorage.setPeer2(peer_[0], peer_[1]);
             }
         }
         if (this.#messageManager.canHandleUpdate(update)) {
-            promises.push(() => this.#messageManager.handleUpdate(update));
+            maybePromises.push(() => this.#messageManager.handleUpdate(update));
         }
         if (this.#chatManager.canHandleUpdate(update)) {
-            promises.push(() => this.#chatManager.handleUpdate(update));
+            maybePromises.push(() => this.#chatManager.handleUpdate(update));
         }
         if (this.#pollManager.canHandleUpdate(update)) {
-            promises.push(() => this.#pollManager.handleUpdate(update));
+            maybePromises.push(() => this.#pollManager.handleUpdate(update));
         }
         if (this.#videoChatManager.canHandleUpdate(update)) {
-            promises.push(() => this.#videoChatManager.handleUpdate(update));
+            maybePromises.push(() => this.#videoChatManager.handleUpdate(update));
         }
         if (this.#callbackQueryManager.canHandleUpdate(update)) {
-            promises.push(() => this.#callbackQueryManager.handleUpdate(update));
+            maybePromises.push(() => this.#callbackQueryManager.handleUpdate(update));
         }
         if (this.#inlineQueryManager.canHandleUpdate(update)) {
-            promises.push(() => this.#inlineQueryManager.handleUpdate(update));
+            maybePromises.push(() => this.#inlineQueryManager.handleUpdate(update));
         }
         if (this.#linkPreviewManager.canHandleUpdate(update)) {
-            promises.push(() => this.#linkPreviewManager.handleUpdate(update));
+            maybePromises.push(() => this.#linkPreviewManager.handleUpdate(update));
         }
         if (this.#reactionManager.canHandleUpdate(update)) {
-            promises.push(() => this.#reactionManager.handleUpdate(update));
+            maybePromises.push(() => this.#reactionManager.handleUpdate(update));
         }
         if (this.#chatListManager.canHandleUpdate(update)) {
-            promises.push(() => this.#chatListManager.handleUpdate(update));
+            maybePromises.push(() => this.#chatListManager.handleUpdate(update));
         }
         if (this.#storyManager.canHandleUpdate(update)) {
-            promises.push(() => this.#storyManager.handleUpdate(update));
+            maybePromises.push(() => this.#storyManager.handleUpdate(update));
         }
         if (this.#businessConnectionManager.canHandleUpdate(update)) {
-            promises.push(() => this.#businessConnectionManager.handleUpdate(update));
+            maybePromises.push(() => this.#businessConnectionManager.handleUpdate(update));
         }
         if (this.#storyManager.canHandleUpdate(update)) {
-            promises.push(() => this.#storyManager.handleUpdate(update));
+            maybePromises.push(() => this.#storyManager.handleUpdate(update));
         }
         if (this.#paymentManager.canHandleUpdate(update)) {
-            promises.push(() => this.#paymentManager.handleUpdate(update));
+            maybePromises.push(() => this.#paymentManager.handleUpdate(update));
         }
         if (this.#translationsManager.canHandleUpdate(update)) {
-            promises.push(() => this.#translationsManager.handleUpdate(update));
+            maybePromises.push(() => this.#translationsManager.handleUpdate(update));
         }
         return () => Promise.resolve().then(async () => {
-            const updates = new Array();
-            for (const promise of promises) {
+            const updates = [{ update }];
+            for (const maybePromise of maybePromises) {
                 try {
-                    const update = await promise();
+                    const value = maybePromise();
+                    const update = value instanceof Promise ? await value : value;
                     if (update) {
                         updates.push(update);
                     }
@@ -1516,7 +1558,6 @@ export class Client extends Composer {
                     if ("deletedMessages" in update) {
                         for (const { chatId, messageId } of update.deletedMessages) {
                             await this.messageStorage.setMessage(chatId, messageId, null);
-                            await this.#chatListManager.reassignChatLastMessage(chatId);
                         }
                     }
                 }
@@ -1525,7 +1566,7 @@ export class Client extends Composer {
     }
     #lastGetMe = null;
     async #getMe() {
-        if (this.#lastGetMe != null) {
+        if (this.#lastGetMe !== null) {
             return this.#lastGetMe;
         }
         else {
@@ -1537,7 +1578,7 @@ export class Client extends Composer {
     #previouslyConnected = false;
     #lastConnectionState = false;
     #onConnectionStateChange(connected) {
-        if (this.#lastConnectionState != connected) {
+        if (this.#lastConnectionState !== connected) {
             if (connected) {
                 if (this.#previouslyConnected) {
                     drop(this.#updateManager.recoverUpdateGap("reconnect"));
@@ -1557,14 +1598,13 @@ export class Client extends Composer {
      * @method ac
      */
     async getMe() {
-        let user_ = await this[getEntity]({ _: "peerUser", user_id: BigInt(await this.#getSelfId()) });
-        if (user_ == null) {
+        let chatP = (await this[getPeer]({ _: "peerUser", user_id: BigInt(await this.#getSelfId()) }))?.[0] ?? null;
+        if (chatP === null) {
             const users = await this.invoke({ _: "users.getUsers", id: [{ _: "inputUserSelf" }] });
-            user_ = Api.as("user", users[0]);
-            await this.messageStorage.setEntity(user_);
-            await this.storage.setIsPremium(user_.premium ?? false);
+            chatP = constructChatP(Api.as("user", users[0]));
+            await this.storage.setIsPremium(chatP.isPremium);
         }
-        const user = constructUser(user_);
+        const user = constructUser2(chatP);
         this.#lastGetMe = user;
         return user;
     }
@@ -2183,14 +2223,12 @@ export class Client extends Composer {
         await this.#messageManager.sendChatAction(chatId, action, params);
     }
     /**
-     * Search the messages of a chat. User-only.
+     * Search for messages. User-only.
      *
      * @method ms
-     * @param chatId The identifier of a chat.
-     * @param query The message search query.
      */
-    async searchMessages(chatId, query, params) {
-        return await this.#messageManager.searchMessages(chatId, query, params);
+    async searchMessages(params) {
+        return await this.#messageManager.searchMessages(params);
     }
     /**
      * Mark messages as read. User-only.
@@ -2224,6 +2262,15 @@ export class Client extends Composer {
         return await this.#messageManager.transcribeVoice(chatId, messageId);
     }
     /**
+     * Get a sticker set.
+     *
+     * @method ms
+     * @param name The name of the sticker set or its link.
+     */
+    async getStickerSet(name) {
+        return await this.#messageManager.getStickerSet(name);
+    }
+    /*
      * Get the link preview for a message that is about to be sent. User-only.
      *
      * @method ms
@@ -2252,6 +2299,23 @@ export class Client extends Composer {
     async getProgressId() {
         return await this.#fileManager.getProgressId();
     }
+    /**
+     * Get messages saved from a specific chat.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     */
+    async getSavedMessages(chatId, params) {
+        return await this.#messageManager.getSavedMessages(chatId, params);
+    }
+    /**
+     * Get a list of saved chats.
+     *
+     * @method ms
+     */
+    async getSavedChats(params) {
+        return await this.#messageManager.getSavedChats(params);
+    }
     //
     // ========================= POLLS ========================= //
     //
@@ -2783,9 +2847,10 @@ export class Client extends Composer {
      * @method ch
      * @param chatId The identifier of the group.
      * @param enabled Whether topics should be enabled in the group.
+     * @param tabs Whether topics should be displayed as tabs.
      */
-    async setTopicsEnabled(chatId, enabled) {
-        await this.#chatManager.setTopicsEnabled(chatId, enabled);
+    async setTopicsEnabled(chatId, enabled, tabs) {
+        await this.#chatManager.setTopicsEnabled(chatId, enabled, tabs);
     }
     /**
      * Enable or disable automatic anti-spam in a group. User-only.