@mtkruto/node 0.0.835 → 0.0.901

package/esm/client/client.js

@@ -1,5 +1,5 @@
-import { debug, gunzip } from "../deps.js";
-import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
+import { debug, gunzip, Mutex, queue } from "../deps.js";
+import { ackThreshold, CHANNEL_DIFFERENCE_LIMIT_BOT, CHANNEL_DIFFERENCE_LIMIT_USER, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, getRandomId } from "../utilities/0_bigint.js";
 import { UNREACHABLE } from "../utilities/0_control.js";
 import { sha1 } from "../utilities/0_hash.js";
@@ -10,9 +10,9 @@ import { as } from "../tl/1_tl_object.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
-import { RPCResult } from "../tl/4_rpc_result.js";
-import { Message } from "../tl/5_message.js";
-import { MessageContainer } from "../tl/6_message_container.js";
+import { RPCResult } from "../tl/5_rpc_result.js";
+import { Message as Message_ } from "../tl/6_message.js"; // MTProto API message
+import { MessageContainer } from "../tl/7_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
 import { StorageMemory } from "../storage/storage_memory.js";
@@ -21,8 +21,12 @@ import { replyKeyboardRemoveToTlObject } from "../types/0_reply_keyboard_remove.
 import { forceReplyToTlObject } from "../types/0_force_reply.js";
 import { replyKeyboardMarkupToTlObject } from "../types/2_reply_keyboard_markup.js";
 import { inlineKeyboardMarkupToTlObject } from "../types/2_inline_keyboard_markup.js";
-import { constructMessage } from "../types/3_message.js";
+import { constructMessage } from "../types/3_message.js"; // high-level wrapper for Telegram API's message
 const d = debug("client");
+const dRecoverUpdateGap = debug("client_recoverUpdateGap");
+const dRecoverChannelUpdateGap = debug("client_recoverChannelUpdateGap");
+const UPDATE_GAP = Symbol();
+export const getEntity = Symbol();
 export const restartAuth = Symbol();
 export var ParseMode;
 (function (ParseMode) {
@@ -88,7 +92,13 @@ export class Client extends ClientAbstract {
             writable: true,
             value: new Set()
         });
-        Object.defineProperty(this, "updatesHandler", {
+        Object.defineProperty(this, "updateState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "updateHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -142,6 +152,79 @@ export class Client extends ClientAbstract {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "messageProcessQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: queue(async (message) => {
+                let body = message.body;
+                if (body instanceof types.GZIPPacked) {
+                    body = new TLReader(gunzip(body.packedData)).readObject();
+                }
+                d("received %s", body.constructor.name);
+                if (body instanceof types.Updates || body instanceof types.TypeUpdate) {
+                    await this.processUpdates(body);
+                }
+                else if (message.body instanceof RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof types.GZIPPacked) {
+                        result = new TLReader(gunzip(result.packedData)).readObject();
+                    }
+                    if (result instanceof types.RPCError) {
+                        d("RPCResult: %d %s", result.errorCode, result.errorMessage);
+                    }
+                    else {
+                        d("RPCResult: %s", result.constructor.name);
+                    }
+                    if (result instanceof types.Updates || result instanceof types.TypeUpdate) {
+                        await this.processUpdates(result);
+                    }
+                    else {
+                        await this.processResult(result);
+                    }
+                    const promise = this.promises.get(message.body.messageId);
+                    if (promise) {
+                        if (result instanceof types.RPCError) {
+                            promise.reject(result);
+                        }
+                        else {
+                            promise.resolve(result);
+                        }
+                        this.promises.delete(message.body.messageId);
+                    }
+                }
+                else if (message.body instanceof types.Pong) {
+                    const promise = this.promises.get(message.body.msgId);
+                    if (promise) {
+                        promise.resolve(message.body);
+                        this.promises.delete(message.body.msgId);
+                    }
+                }
+                else if (message.body instanceof types.BadMsgNotification || message.body instanceof types.BadServerSalt) {
+                    if (message.body instanceof types.BadServerSalt) {
+                        this.state.salt = message.body.newServerSalt;
+                    }
+                    const promise = this.promises.get(message.body.badMsgId);
+                    if (promise) {
+                        promise.resolve(message.body);
+                        this.promises.delete(message.body.badMsgId);
+                    }
+                }
+                this.toAcknowledge.add(message.id);
+            }, 2)
+        });
+        Object.defineProperty(this, "updateApplicationMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Mutex()
+        });
+        Object.defineProperty(this, "updateGapRecoveryMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Mutex()
+        });
         this.parseMode = params?.parseMode ?? ParseMode.None;
         this.appVersion = params?.appVersion ?? DEFAULT_APP_VERSION;
         this.deviceModel = params?.deviceModel ?? DEFAULT_DEVICE_MODEL;
@@ -164,6 +247,7 @@ export class Client extends ClientAbstract {
         if (await this.storage.getDc() != dc) {
             await this.storage.setDc(dc);
             await this.storage.setAuthKey(null);
+            await this.storage.getAuthKey();
         }
         super.setDc(dc);
     }
@@ -205,12 +289,17 @@ export class Client extends ClientAbstract {
         }
         await super.connect();
         if (dc == null) {
-            await this.storage.setDc(DEFAULT_INITIAL_DC);
+            await this.storage.setDc(this.transportProvider.initialDc);
         }
         d("enrypted client connected");
         this.receiveLoop();
         this.pingLoop();
     }
+    async fetchState(source) {
+        const state = await this.invoke(new functions.UpdatesGetState());
+        this.updateState = state;
+        d("state fetched [%s]", source);
+    }
     /**
      * Calls [initConnection](1) and authorizes the client with one of the following:
      *
@@ -260,6 +349,7 @@ export class Client extends ClientAbstract {
                             const password = typeof params.password === "string" ? params.password : await params.password();
                             const input = await checkPassword(password, ap);
                             await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                            await this.storage.setAccountType("user");
                             d("authorized as user");
                             break;
                         }
@@ -282,7 +372,7 @@ export class Client extends ClientAbstract {
             }
         };
         try {
-            await this.invoke(new functions.UpdatesGetState());
+            await this.fetchState("authorize");
             d("already authorized");
             return;
         }
@@ -323,6 +413,7 @@ export class Client extends ClientAbstract {
                                         }
                                         else {
                                             signedIn = true;
+                                            await this.storage.setAccountType("user");
                                             d("authorized as user");
                                             break;
                                         }
@@ -357,6 +448,7 @@ export class Client extends ClientAbstract {
             }
             else {
                 await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
+                await this.storage.setAccountType("bot");
                 d("authorized as bot");
             }
         }
@@ -384,6 +476,14 @@ export class Client extends ClientAbstract {
                 throw err;
             }
         }
+        finally {
+            try {
+                await this.fetchState("authorize");
+            }
+            catch (_err) {
+                //
+            }
+        }
     }
     async receiveLoop() {
         if (!this.auth) {
@@ -416,58 +516,7 @@ export class Client extends ClientAbstract {
             }
             const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
             for (const message of messages) {
-                let body = message.body;
-                if (body instanceof types.GZIPPacked) {
-                    body = new TLReader(gunzip(body.packedData)).readObject();
-                }
-                d("received %s", body.constructor.name);
-                if (body instanceof types.Updates) {
-                    this.processUpdates(body);
-                }
-                else if (message.body instanceof RPCResult) {
-                    let result = message.body.result;
-                    if (result instanceof types.GZIPPacked) {
-                        result = new TLReader(gunzip(result.packedData)).readObject();
-                    }
-                    if (result instanceof types.RPCError) {
-                        d("RPCResult: %d %s", result.errorCode, result.errorMessage);
-                    }
-                    else {
-                        d("RPCResult: %s", result.constructor.name);
-                    }
-                    const promise = this.promises.get(message.body.messageId);
-                    if (promise) {
-                        if (result instanceof types.RPCError) {
-                            promise.reject(result);
-                        }
-                        else {
-                            if (result instanceof types.Updates) {
-                                await this.processChats(result.chats);
-                                await this.processUsers(result.users);
-                            }
-                            promise.resolve(result);
-                        }
-                        this.promises.delete(message.body.messageId);
-                    }
-                }
-                else if (message.body instanceof types.Pong) {
-                    const promise = this.promises.get(message.body.msgId);
-                    if (promise) {
-                        promise.resolve(message.body);
-                        this.promises.delete(message.body.msgId);
-                    }
-                }
-                else if (message.body instanceof types.BadMsgNotification || message.body instanceof types.BadServerSalt) {
-                    if (message.body instanceof types.BadServerSalt) {
-                        this.state.salt = message.body.newServerSalt;
-                    }
-                    const promise = this.promises.get(message.body.badMsgId);
-                    if (promise) {
-                        promise.resolve(message.body);
-                        this.promises.delete(message.body.badMsgId);
-                    }
-                }
-                this.toAcknowledge.add(message.id);
+                this.messageProcessQueue.push(message);
             }
         }
     }
@@ -491,7 +540,7 @@ export class Client extends ClientAbstract {
             seqNo++;
             this.state.seqNo++;
         }
-        const message = new Message(getMessageId(), seqNo, function_);
+        const message = new Message_(getMessageId(), seqNo, function_);
         await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
         d("invoked %s", function_.constructor.name);
         if (noWait) {
@@ -516,6 +565,7 @@ export class Client extends ClientAbstract {
     async processChats(chats) {
         for (const chat of chats) {
             if (chat instanceof types.Channel && chat.accessHash) {
+                await this.storage.setEntity(chat);
                 await this.storage.setChannelAccessHash(chat.id, chat.accessHash);
                 if (chat.username) {
                     await this.storage.updateUsernames("channel", chat.id, [chat.username]);
@@ -524,11 +574,15 @@ export class Client extends ClientAbstract {
                     await this.storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
                 }
             }
+            else if (chat instanceof types.Chat) {
+                await this.storage.setEntity(chat);
+            }
         }
     }
     async processUsers(users) {
         for (const user of users) {
             if (user instanceof types.User && user.accessHash) {
+                await this.storage.setEntity(user);
                 await this.storage.setUserAccessHash(user.id, user.accessHash);
                 if (user.username) {
                     await this.storage.updateUsernames("user", user.id, [user.username]);
@@ -539,19 +593,310 @@ export class Client extends ClientAbstract {
             }
         }
     }
+    async applyUpdateNoGap(update, usePts = true) {
+        const release = await this.updateApplicationMutex.acquire();
+        try {
+            if ((update instanceof types.UpdateNewMessage) ||
+                (update instanceof types.UpdateDeleteMessages) ||
+                (update instanceof types.UpdateReadHistoryInbox) ||
+                (update instanceof types.UpdateReadHistoryOutbox) ||
+                (update instanceof types.UpdateWebPage) ||
+                (update instanceof types.UpdateReadMessagesContents) ||
+                (update instanceof types.UpdateEditMessage) ||
+                (update instanceof types.UpdateFolderPeers) ||
+                (update instanceof types.UpdatePinnedMessages) ||
+                (update instanceof types.UpdatePinnedChannelMessages) ||
+                (update instanceof types.UpdateShortMessage) ||
+                (update instanceof types.UpdateShortChatMessage) ||
+                (update instanceof types.UpdateShortSentMessage)) {
+                const localState = await this.getLocalState();
+                if (localState.pts + update.ptsCount > update.pts) {
+                    // the update is already applied
+                    return;
+                }
+                else if (localState.pts + update.ptsCount < update.pts) {
+                    // there is an update gap that needs to be filled
+                    throw UPDATE_GAP;
+                }
+                localState.pts = update.pts;
+                d("applied update with pts %d", update.pts);
+                await this.storage.setState(localState);
+            }
+            else if (usePts &&
+                ((update instanceof types.UpdateNewChannelMessage) ||
+                    (update instanceof types.UpdateDeleteChannelMessages) ||
+                    (update instanceof types.UpdateEditChannelMessage) ||
+                    (update instanceof types.UpdateChannelWebPage))) {
+                const channelId = update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage ? update.message[as](types.Message).peerId[as](types.PeerChannel).channelId : update.channelId;
+                let localPts = await this.storage.getChannelPts(channelId);
+                if (!localPts) {
+                    localPts = update.pts - update.ptsCount;
+                }
+                if (localPts + update.ptsCount > update.pts) {
+                    // already applied
+                    return;
+                }
+                else if (localPts + update.ptsCount < update.pts) {
+                    // should call channelGetDifference
+                    throw UPDATE_GAP;
+                }
+                d("applied update with pts %d", update.pts);
+                await this.storage.setChannelPts(channelId, update.pts);
+            }
+            // apply update (call listeners)
+            this.updateHandler?.(this, update);
+        }
+        finally {
+            release();
+        }
+    }
+    async applyUpdate(update) {
+        if (update instanceof types.TypeUpdates &&
+            !(update instanceof types.UpdateShortMessage) &&
+            !(update instanceof types.UpdateShortChatMessage) &&
+            !(update instanceof types.UpdateShortSentMessage)) {
+            // other constructors inheriting Updates are not applicable
+            UNREACHABLE();
+        }
+        if (update instanceof types.TypeUpdate && update instanceof types.UpdateChannelTooLong) {
+            // updateChannelTooLong is not applicable
+            UNREACHABLE();
+        }
+        // can't apply updates when filling gap
+        const release = await this.updateGapRecoveryMutex.acquire();
+        try {
+            await this.applyUpdateNoGap(update);
+            release();
+        }
+        catch (err) {
+            release();
+            if (err == UPDATE_GAP) {
+                if ((update instanceof types.UpdateNewChannelMessage) ||
+                    (update instanceof types.UpdateDeleteChannelMessages) ||
+                    (update instanceof types.UpdateEditChannelMessage) ||
+                    (update instanceof types.UpdateChannelWebPage)) {
+                    const channelId = update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage ? update.message[as](types.Message).peerId[as](types.PeerChannel).channelId : update.channelId;
+                    await this.recoverChannelUpdateGap(channelId, "applyUpdate");
+                }
+                else if ((update instanceof types.UpdateNewMessage) ||
+                    (update instanceof types.UpdateDeleteMessages) ||
+                    (update instanceof types.UpdateReadHistoryInbox) ||
+                    (update instanceof types.UpdateReadHistoryOutbox) ||
+                    (update instanceof types.UpdateWebPage) ||
+                    (update instanceof types.UpdateReadMessagesContents) ||
+                    (update instanceof types.UpdateEditMessage) ||
+                    (update instanceof types.UpdateFolderPeers) ||
+                    (update instanceof types.UpdatePinnedMessages) ||
+                    (update instanceof types.UpdatePinnedChannelMessages) ||
+                    (update instanceof types.UpdateShortMessage) ||
+                    (update instanceof types.UpdateShortChatMessage) ||
+                    (update instanceof types.UpdateShortSentMessage)) {
+                    await this.recoverUpdateGap("applyUpdate");
+                }
+                else {
+                    // can't detect update gap from other types of updates
+                    UNREACHABLE();
+                }
+                // just for integrity
+                const release = await this.updateGapRecoveryMutex.acquire();
+                try {
+                    await this.applyUpdateNoGap(update);
+                }
+                catch (err) {
+                    if (err == UPDATE_GAP) {
+                        // the gap must have been filled until now
+                        UNREACHABLE();
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                finally {
+                    release();
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
     async processUpdates(updates) {
         try {
-            await this.processChats(updates.chats);
-            await this.processUsers(updates.users);
-            for (const update of updates.updates) {
-                if (update instanceof types.UpdateUserName) {
-                    await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+            if (updates instanceof types.TypeUpdates) {
+                if (updates instanceof types.Updates) {
+                    await this.processChats(updates.chats);
+                    await this.processUsers(updates.users);
+                    await this.setUpdateStateDate(updates.date);
+                    for (const update of updates.updates) {
+                        await this.processUpdates(update);
+                    }
+                }
+                else if (updates instanceof types.UpdateShortMessage ||
+                    updates instanceof types.UpdateShortChatMessage ||
+                    updates instanceof types.UpdateShortSentMessage) {
+                    await this.setUpdateStateDate(updates.date);
+                    await this.applyUpdate(updates);
+                }
+                else if (updates instanceof types.UpdatesTooLong) {
+                    await this.recoverUpdateGap("updatesTooLong");
+                }
+                else if (updates instanceof types.UpdatesCombined) {
+                    await this.setUpdateStateDate(updates.date);
+                    await this.processChats(updates.chats);
+                    await this.processUsers(updates.users);
+                    for (const update of updates.updates) {
+                        await this.processUpdates(update);
+                    }
+                }
+            }
+            else if (updates instanceof types.TypeUpdate && updates instanceof types.UpdateChannelTooLong) {
+                if (updates.pts != undefined) {
+                    await this.storage.setChannelPts(updates.channelId, updates.pts);
+                }
+                await this.recoverChannelUpdateGap(updates.channelId, "updateChannelTooLong");
+            }
+            else {
+                if (updates instanceof types.UpdateUserName) {
+                    await this.storage.updateUsernames("user", updates.userId, updates.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+                else if (updates instanceof types.UpdatePtsChanged) {
+                    await this.fetchState("updatePtsChanged");
+                    if (this.updateState) {
+                        await this.storage.setState(this.updateState);
+                    }
+                    else {
+                        UNREACHABLE();
+                    }
                 }
+                await this.applyUpdate(updates);
             }
-            await this.updatesHandler?.(this, updates);
         }
         catch (err) {
-            console.error("Error processing updates:", err);
+            d("error processing updates: %O", err);
+        }
+    }
+    async setUpdateStateDate(date) {
+        const release = await this.updateApplicationMutex.acquire();
+        try {
+            const localState = await this.getLocalState();
+            localState.date = date;
+            await this.storage.setState(localState);
+        }
+        finally {
+            release();
+        }
+    }
+    async getLocalState() {
+        let localState = await this.storage.getState();
+        if (!localState) {
+            if (this.updateState) {
+                localState = this.updateState;
+                await this.storage.setState(localState);
+            }
+            else {
+                UNREACHABLE();
+            }
+        }
+        return localState;
+    }
+    async recoverUpdateGap(source) {
+        dRecoverUpdateGap("recovering from update gap [%s]", source);
+        const release = await this.updateGapRecoveryMutex.acquire();
+        try {
+            let state = await this.getLocalState();
+            while (true) {
+                const difference = await this.invoke(new functions.UpdatesGetDifference({ pts: state.pts, date: state.date, qts: state.qts }));
+                if (difference instanceof types.UpdatesDifference || difference instanceof types.UpdatesDifferenceSlice) {
+                    await this.processChats(difference.chats);
+                    await this.processUsers(difference.users);
+                    for (const message of difference.newMessages) {
+                        await this.applyUpdateNoGap(new types.UpdateNewMessage({ message, pts: 0, ptsCount: 0 }));
+                    }
+                    for (const update of difference.otherUpdates) {
+                        await this.applyUpdateNoGap(update);
+                    }
+                    if (difference instanceof types.UpdatesDifference) {
+                        dRecoverUpdateGap("recovered from update gap");
+                        break;
+                    }
+                    else if (difference instanceof types.UpdatesDifferenceSlice) {
+                        state = difference.intermediateState[as](types.UpdatesState);
+                    }
+                    else {
+                        UNREACHABLE();
+                    }
+                }
+                else if (difference instanceof types.UpdatesDifferenceTooLong) {
+                    // stored messages should be invalidated in case we store messages in the future
+                    state.pts = difference.pts;
+                    dRecoverUpdateGap("received differenceTooLong");
+                }
+                else if (difference instanceof types.UpdatesDifferenceEmpty) {
+                    await this.setUpdateStateDate(difference.date);
+                    dRecoverUpdateGap("there was no update gap");
+                    break;
+                }
+                else {
+                    UNREACHABLE();
+                }
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async recoverChannelUpdateGap(channelId, source) {
+        dRecoverChannelUpdateGap("recovering channel update gap [%o, %s]", channelId, source);
+        const release = await this.updateGapRecoveryMutex.acquire();
+        try {
+            const pts_ = await this.storage.getChannelPts(channelId);
+            let pts = pts_ == null ? 1 : pts_;
+            while (true) {
+                const { accessHash } = await this.getInputPeer(ZERO_CHANNEL_ID + -Number(channelId)).then((v) => v[as](types.InputPeerChannel));
+                const difference = await this.invoke(new functions.UpdatesGetChannelDifference({
+                    pts,
+                    channel: new types.InputChannel({ channelId, accessHash: accessHash }),
+                    filter: new types.ChannelMessagesFilterEmpty(),
+                    limit: await this.storage.getAccountType() == "user" ? CHANNEL_DIFFERENCE_LIMIT_USER : CHANNEL_DIFFERENCE_LIMIT_BOT,
+                }));
+                if (difference instanceof types.UpdatesChannelDifference) {
+                    await this.processChats(difference.chats);
+                    await this.processUsers(difference.users);
+                    for (const message of difference.newMessages) {
+                        await this.applyUpdateNoGap(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), false);
+                    }
+                    for (const update of difference.otherUpdates) {
+                        await this.applyUpdateNoGap(update, false);
+                    }
+                    await this.storage.setChannelPts(channelId, difference.pts);
+                    dRecoverChannelUpdateGap("recovered from update gap");
+                    break;
+                }
+                else if (difference instanceof types.UpdatesChannelDifferenceTooLong) {
+                    // invalidate messages
+                    dRecoverChannelUpdateGap("received channelDifferenceTooLong");
+                    await this.processChats(difference.chats);
+                    await this.processUsers(difference.users);
+                    for (const message of difference.messages) {
+                        await this.applyUpdateNoGap(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), false);
+                    }
+                    const pts_ = difference.dialog[as](types.Dialog).pts;
+                    if (pts_ != undefined) {
+                        pts = pts_;
+                    }
+                    else {
+                        UNREACHABLE();
+                    }
+                    dRecoverChannelUpdateGap("processed channelDifferenceTooLong");
+                }
+                else if (difference instanceof types.UpdatesChannelDifferenceEmpty) {
+                    dRecoverChannelUpdateGap("there was no update gap");
+                    break;
+                }
+            }
+        }
+        finally {
+            release();
         }
     }
     async getInputPeer(id) {
@@ -620,6 +965,50 @@ export class Client extends ClientAbstract {
             throw new Error("ID format unknown or not implemented");
         }
     }
+    [getEntity](peer) {
+        const type = peer instanceof types.PeerUser ? "user" : peer instanceof types.PeerChat ? "chat" : peer instanceof types.PeerChannel ? "channel" : UNREACHABLE();
+        const id = peer instanceof types.PeerUser ? peer.userId : peer instanceof types.PeerChat ? peer.chatId : peer instanceof types.PeerChannel ? peer.channelId : UNREACHABLE();
+        return this.storage.getEntity(type, id);
+    }
+    async processResult(result) {
+        if (result instanceof types.MessagesDialogs ||
+            result instanceof types.MessagesDialogsSlice ||
+            result instanceof types.MessagesMessages ||
+            result instanceof types.MessagesMessagesSlice ||
+            result instanceof types.MessagesChannelMessages ||
+            result instanceof types.MessagesChatFull ||
+            result instanceof types.ContactsFound ||
+            result instanceof types.AccountPrivacyRules ||
+            result instanceof types.ContactsResolvedPeer ||
+            result instanceof types.ChannelsChannelParticipants ||
+            result instanceof types.ChannelsChannelParticipant ||
+            result instanceof types.MessagesPeerDialogs ||
+            result instanceof types.ContactsTopPeers ||
+            result instanceof types.ChannelsAdminLogResults ||
+            result instanceof types.HelpRecentMeURLs ||
+            result instanceof types.MessagesInactiveChats ||
+            result instanceof types.HelpPromoData ||
+            result instanceof types.MessagesMessageViews ||
+            result instanceof types.MessagesDiscussionMessage ||
+            result instanceof types.PhoneGroupCall ||
+            result instanceof types.PhoneGroupParticipants ||
+            result instanceof types.PhoneJoinAsPeers ||
+            result instanceof types.MessagesSponsoredMessages ||
+            result instanceof types.MessagesSearchResultsCalendar ||
+            result instanceof types.ChannelsSendAsPeers ||
+            result instanceof types.UsersUserFull ||
+            result instanceof types.MessagesPeerSettings ||
+            result instanceof types.MessagesMessageReactionsList ||
+            result instanceof types.MessagesForumTopics ||
+            result instanceof types.AccountAutoSaveSettings ||
+            result instanceof types.ChatlistsExportedInvites ||
+            result instanceof types.ChatlistsChatlistInviteAlready ||
+            result instanceof types.ChatlistsChatlistInvite ||
+            result instanceof types.ChatlistsChatlistUpdates) {
+            await this.processChats(result.chats);
+            await this.processUsers(result.users);
+        }
+    }
     async sendMessage(chatId, text, params) {
         const entities_ = params?.entities ?? [];
         const parseMode = params?.parseMode ?? this.parseMode;
@@ -665,7 +1054,7 @@ export class Client extends ClientAbstract {
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
         const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-        const updates = await this.invoke(new functions.MessagesSendMessage({
+        const result = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
             message,
@@ -677,15 +1066,47 @@ export class Client extends ClientAbstract {
             sendAs,
             entities,
             replyMarkup,
-        })).then((v) => v[as](types.Updates));
-        for (const update of updates.updates) {
-            if (update instanceof types.UpdateNewMessage) {
-                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+        }));
+        if (result instanceof types.Updates) {
+            for (const update of result.updates) {
+                if (update instanceof types.UpdateNewMessage) {
+                    return constructMessage(update.message[as](types.Message), this[getEntity].bind(this));
+                }
+                else if (update instanceof types.UpdateNewChannelMessage) {
+                    return constructMessage(update.message[as](types.Message), this[getEntity].bind(this));
+                }
             }
-            else if (update instanceof types.UpdateNewChannelMessage) {
-                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+        }
+        else if (result instanceof types.UpdateShortSentMessage || result instanceof types.UpdateShortSentMessage) {
+            const message = await this.getMessage(chatId, result.id);
+            if (message != null) {
+                return message;
             }
         }
         UNREACHABLE();
     }
+    async getMessages(chatId, messageIds) {
+        const peer = await this.getInputPeer(chatId);
+        let messages_;
+        if (peer instanceof types.InputPeerChannel) {
+            messages_ = await this.invoke(new functions.ChannelsGetMessages({
+                channel: new types.InputChannel({ channelId: peer.channelId, accessHash: peer.accessHash }),
+                id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+            })).then((v) => v[as](types.MessagesMessages));
+        }
+        else {
+            messages_ = await this.invoke(new functions.MessagesGetMessages({
+                id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+            })).then((v) => v[as](types.MessagesMessages));
+        }
+        const messages = new Array();
+        for (const message_ of messages_.messages) {
+            messages.push(await constructMessage(message_[as](types.Message), this[getEntity].bind(this)));
+        }
+        return messages;
+    }
+    async getMessage(chatId, messageId) {
+        const messages = await this.getMessages(chatId, [messageId]);
+        return messages[0] ?? null;
+    }
 }