@mtkruto/node 0.0.834 → 0.0.900

package/script/client/client.js

@@ -23,10 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.ParseMode = exports.restartAuth = void 0;
+exports.Client = exports.ParseMode = exports.restartAuth = exports.getEntity = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
+const _0_control_js_1 = require("../utilities/0_control.js");
+const _0_hash_js_1 = require("../utilities/0_hash.js");
 const _0_html_js_1 = require("../utilities/0_html.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
 const _1_password_js_1 = require("../utilities/1_password.js");
@@ -34,15 +36,23 @@ const _1_tl_object_js_1 = require("../tl/1_tl_object.js");
 const types = __importStar(require("../tl/2_types.js"));
 const functions = __importStar(require("../tl/3_functions.js"));
 const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
-const _4_rpc_result_js_1 = require("../tl/4_rpc_result.js");
-const _5_message_js_1 = require("../tl/5_message.js");
-const _6_message_container_js_1 = require("../tl/6_message_container.js");
+const _5_rpc_result_js_1 = require("../tl/5_rpc_result.js");
+const _6_message_js_1 = require("../tl/6_message.js"); // MTProto API message
+const _7_message_container_js_1 = require("../tl/7_message_container.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
 const storage_memory_js_1 = require("../storage/storage_memory.js");
-const _0_hash_js_1 = require("../utilities/0_hash.js");
 const _0_message_entity_js_1 = require("../types/0_message_entity.js");
+const _0_reply_keyboard_remove_js_1 = require("../types/0_reply_keyboard_remove.js");
+const _0_force_reply_js_1 = require("../types/0_force_reply.js");
+const _2_reply_keyboard_markup_js_1 = require("../types/2_reply_keyboard_markup.js");
+const _2_inline_keyboard_markup_js_1 = require("../types/2_inline_keyboard_markup.js");
+const _3_message_js_1 = require("../types/3_message.js"); // high-level wrapper for Telegram API's message
 const d = (0, deps_js_1.debug)("client");
+const dRecoverUpdateGap = (0, deps_js_1.debug)("client_recoverUpdateGap");
+const dRecoverChannelUpdateGap = (0, deps_js_1.debug)("client_recoverChannelUpdateGap");
+const UPDATE_GAP = Symbol();
+exports.getEntity = Symbol();
 exports.restartAuth = Symbol();
 var ParseMode;
 (function (ParseMode) {
@@ -108,7 +118,13 @@ class Client extends client_abstract_js_1.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,
@@ -162,6 +178,79 @@ class Client extends client_abstract_js_1.ClientAbstract {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "messageProcessQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, deps_js_1.queue)(async (message) => {
+                let body = message.body;
+                if (body instanceof types.GZIPPacked) {
+                    body = new _3_tl_reader_js_1.TLReader((0, deps_js_1.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 _5_rpc_result_js_1.RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof types.GZIPPacked) {
+                        result = new _3_tl_reader_js_1.TLReader((0, deps_js_1.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 deps_js_1.Mutex()
+        });
+        Object.defineProperty(this, "updateGapRecoveryMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new deps_js_1.Mutex()
+        });
         this.parseMode = params?.parseMode ?? ParseMode.None;
         this.appVersion = params?.appVersion ?? constants_js_1.DEFAULT_APP_VERSION;
         this.deviceModel = params?.deviceModel ?? constants_js_1.DEFAULT_DEVICE_MODEL;
@@ -231,6 +320,11 @@ class Client extends client_abstract_js_1.ClientAbstract {
         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:
      *
@@ -280,6 +374,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                             const password = typeof params.password === "string" ? params.password : await params.password();
                             const input = await (0, _1_password_js_1.checkPassword)(password, ap);
                             await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                            await this.storage.setAccountType("user");
                             d("authorized as user");
                             break;
                         }
@@ -302,7 +397,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
             }
         };
         try {
-            await this.invoke(new functions.UpdatesGetState());
+            await this.fetchState("authorize");
             d("already authorized");
             return;
         }
@@ -343,6 +438,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                                         }
                                         else {
                                             signedIn = true;
+                                            await this.storage.setAccountType("user");
                                             d("authorized as user");
                                             break;
                                         }
@@ -377,6 +473,7 @@ class Client extends client_abstract_js_1.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");
             }
         }
@@ -404,6 +501,14 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 throw err;
             }
         }
+        finally {
+            try {
+                await this.fetchState("authorize");
+            }
+            catch (_err) {
+                //
+            }
+        }
     }
     async receiveLoop() {
         if (!this.auth) {
@@ -434,60 +539,9 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 d("failed to decrypt message: %o", err);
                 continue;
             }
-            const messages = decrypted instanceof _6_message_container_js_1.MessageContainer ? decrypted.messages : [decrypted];
+            const messages = decrypted instanceof _7_message_container_js_1.MessageContainer ? decrypted.messages : [decrypted];
             for (const message of messages) {
-                let body = message.body;
-                if (body instanceof types.GZIPPacked) {
-                    body = new _3_tl_reader_js_1.TLReader((0, deps_js_1.gunzip)(body.packedData)).readObject();
-                }
-                d("received %s", body.constructor.name);
-                if (body instanceof types.Updates) {
-                    this.processUpdates(body);
-                }
-                else if (message.body instanceof _4_rpc_result_js_1.RPCResult) {
-                    let result = message.body.result;
-                    if (result instanceof types.GZIPPacked) {
-                        result = new _3_tl_reader_js_1.TLReader((0, deps_js_1.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);
             }
         }
     }
@@ -511,7 +565,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
             seqNo++;
             this.state.seqNo++;
         }
-        const message = new _5_message_js_1.Message((0, _1_message_js_1.getMessageId)(), seqNo, function_);
+        const message = new _6_message_js_1.Message((0, _1_message_js_1.getMessageId)(), seqNo, function_);
         await this.transport.send(await (0, _1_message_js_1.encryptMessage)(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
         d("invoked %s", function_.constructor.name);
         if (noWait) {
@@ -536,6 +590,7 @@ class Client extends client_abstract_js_1.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]);
@@ -544,11 +599,15 @@ class Client extends client_abstract_js_1.ClientAbstract {
                     await this.storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v[_1_tl_object_js_1.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]);
@@ -559,19 +618,310 @@ class Client extends client_abstract_js_1.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[_1_tl_object_js_1.as](types.Message).peerId[_1_tl_object_js_1.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
+            (0, _0_control_js_1.UNREACHABLE)();
+        }
+        if (update instanceof types.TypeUpdate && update instanceof types.UpdateChannelTooLong) {
+            // updateChannelTooLong is not applicable
+            (0, _0_control_js_1.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[_1_tl_object_js_1.as](types.Message).peerId[_1_tl_object_js_1.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
+                    (0, _0_control_js_1.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
+                        (0, _0_control_js_1.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[_1_tl_object_js_1.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);
+                    }
                 }
             }
-            await this.updatesHandler?.(this, updates);
+            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[_1_tl_object_js_1.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 {
+                        (0, _0_control_js_1.UNREACHABLE)();
+                    }
+                }
+                await this.applyUpdate(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 {
+                (0, _0_control_js_1.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[_1_tl_object_js_1.as](types.UpdatesState);
+                    }
+                    else {
+                        (0, _0_control_js_1.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 {
+                    (0, _0_control_js_1.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(constants_js_1.ZERO_CHANNEL_ID + -Number(channelId)).then((v) => v[_1_tl_object_js_1.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" ? constants_js_1.CHANNEL_DIFFERENCE_LIMIT_USER : constants_js_1.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[_1_tl_object_js_1.as](types.Dialog).pts;
+                    if (pts_ != undefined) {
+                        pts = pts_;
+                    }
+                    else {
+                        (0, _0_control_js_1.UNREACHABLE)();
+                    }
+                    dRecoverChannelUpdateGap("processed channelDifferenceTooLong");
+                }
+                else if (difference instanceof types.UpdatesChannelDifferenceEmpty) {
+                    dRecoverChannelUpdateGap("there was no update gap");
+                    break;
+                }
+            }
+        }
+        finally {
+            release();
         }
     }
     async getInputPeer(id) {
@@ -607,7 +957,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                         channelId = resolved.peer.channelId;
                     }
                     else {
-                        throw new Error("Unreachable");
+                        (0, _0_control_js_1.UNREACHABLE)();
                     }
                 }
                 if (userId) {
@@ -619,7 +969,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                     return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
                 }
                 else {
-                    throw new Error("Unreachable");
+                    (0, _0_control_js_1.UNREACHABLE)();
                 }
             }
         }
@@ -640,6 +990,50 @@ class Client extends client_abstract_js_1.ClientAbstract {
             throw new Error("ID format unknown or not implemented");
         }
     }
+    [exports.getEntity](peer) {
+        const type = peer instanceof types.PeerUser ? "user" : peer instanceof types.PeerChat ? "chat" : peer instanceof types.PeerChannel ? "channel" : (0, _0_control_js_1.UNREACHABLE)();
+        const id = peer instanceof types.PeerUser ? peer.userId : peer instanceof types.PeerChat ? peer.chatId : peer instanceof types.PeerChannel ? peer.channelId : (0, _0_control_js_1.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;
@@ -654,6 +1048,27 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 }
             }
         }
+        let replyMarkup = undefined;
+        if (params?.replyMarkup) {
+            if ("inlineKeyboard" in params.replyMarkup) {
+                replyMarkup = await (0, _2_inline_keyboard_markup_js_1.inlineKeyboardMarkupToTlObject)(params.replyMarkup, async (v) => {
+                    const inputPeer = await this.getInputPeer(v).then((v) => v[_1_tl_object_js_1.as](types.InputPeerUser));
+                    return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
+                });
+            }
+            else if ("keyboard" in params.replyMarkup) {
+                replyMarkup = (0, _2_reply_keyboard_markup_js_1.replyKeyboardMarkupToTlObject)(params.replyMarkup);
+            }
+            else if ("removeKeyboard" in params.replyMarkup) {
+                replyMarkup = (0, _0_reply_keyboard_remove_js_1.replyKeyboardRemoveToTlObject)(params.replyMarkup);
+            }
+            else if ("forceReply" in params.replyMarkup) {
+                replyMarkup = (0, _0_force_reply_js_1.forceReplyToTlObject)(params.replyMarkup);
+            }
+            else {
+                throw new Error("The replyMarkup parameter has an unexpected type");
+            }
+        }
         const peer = await this.getInputPeer(chatId);
         const randomId = (0, _0_bigint_js_1.getRandomId)();
         const message = text;
@@ -664,7 +1079,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
         const entities = entities_?.length > 0 ? entities_.map((v) => (0, _0_message_entity_js_1.messageEntityToTlObject)(v)) : undefined;
-        return await this.invoke(new functions.MessagesSendMessage({
+        const result = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
             message,
@@ -675,7 +1090,49 @@ class Client extends client_abstract_js_1.ClientAbstract {
             topMsgId,
             sendAs,
             entities,
+            replyMarkup,
         }));
+        if (result instanceof types.Updates) {
+            for (const update of result.updates) {
+                if (update instanceof types.UpdateNewMessage) {
+                    return (0, _3_message_js_1.constructMessage)(update.message[_1_tl_object_js_1.as](types.Message), this[exports.getEntity].bind(this));
+                }
+                else if (update instanceof types.UpdateNewChannelMessage) {
+                    return (0, _3_message_js_1.constructMessage)(update.message[_1_tl_object_js_1.as](types.Message), this[exports.getEntity].bind(this));
+                }
+            }
+        }
+        else if (result instanceof types.UpdateShortSentMessage || result instanceof types.UpdateShortSentMessage) {
+            const message = await this.getMessage(chatId, result.id);
+            if (message != null) {
+                return message;
+            }
+        }
+        (0, _0_control_js_1.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[_1_tl_object_js_1.as](types.MessagesMessages));
+        }
+        else {
+            messages_ = await this.invoke(new functions.MessagesGetMessages({
+                id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+            })).then((v) => v[_1_tl_object_js_1.as](types.MessagesMessages));
+        }
+        const messages = new Array();
+        for (const message_ of messages_.messages) {
+            messages.push(await (0, _3_message_js_1.constructMessage)(message_[_1_tl_object_js_1.as](types.Message), this[exports.getEntity].bind(this)));
+        }
+        return messages;
+    }
+    async getMessage(chatId, messageId) {
+        const messages = await this.getMessages(chatId, [messageId]);
+        return messages[0] ?? null;
     }
 }
 exports.Client = Client;