@mtkruto/node 0.0.986 → 0.0.987

package/esm/client/3_client.js

@@ -24,15 +24,15 @@ import { checkPassword } from "./0_password.js";
 import { ClientAbstract } from "./1_client_abstract.js";
 import { ClientPlain } from "./2_client_plain.js";
 import { drop, mustPrompt, mustPromptOneOf } from "../utilities/1_misc.js";
-import { getChannelChatId, peerToChatId } from "./0_utilities.js";
+import { getChannelChatId, hasChannelPts, hasPts, peerToChatId } from "./0_utilities.js";
 import { constructUser } from "../types/1_user.js";
 import { TLError } from "../tl/0_tl_raw_reader.js";
+import { Queue } from "../utilities/0_queue.js";
 const d = debug("Client");
 const dGap = debug("Client/recoverUpdateGap");
 const dGapC = debug("Client/recoverChannelUpdateGap");
 const dAuth = debug("Client/authorize");
 const dRecv = debug("Client/receiveLoop");
-const UPDATE_GAP = Symbol();
 export const getEntity = Symbol();
 export const getStickerSetName = Symbol();
 export const handleMigrationError = Symbol();
@@ -51,8 +51,8 @@ export class Client extends ClientAbstract {
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      * @param params Other parameters.
      */
-    constructor(storage = new StorageMemory(), apiId = 0, apiHash = "", params, cdn = false) {
-        super(params?.transportProvider, cdn);
+    constructor(storage = new StorageMemory(), apiId = 0, apiHash = "", params) {
+        super(params);
         Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
@@ -107,12 +107,6 @@ export class Client extends ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "updateHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
         Object.defineProperty(this, "parseMode", {
             enumerable: true,
             configurable: true,
@@ -167,12 +161,26 @@ export class Client extends ClientAbstract {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "stateChangeHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ((connected) => {
+                this.propagateConnectionState(connected ? "ready" : "not-connected");
+            }).bind(this)
+        });
         Object.defineProperty(this, "storageInited", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "connectMutex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Mutex()
+        });
         Object.defineProperty(this, "connectionInited", {
             enumerable: true,
             configurable: true,
@@ -191,23 +199,25 @@ export class Client extends ClientAbstract {
             writable: true,
             value: 0n
         });
-        Object.defineProperty(this, "updateApplicationMutex", {
+        Object.defineProperty(this, "handleUpdateQueue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Mutex()
+            value: new Queue()
         });
-        Object.defineProperty(this, "updateProcessLock", {
+        Object.defineProperty(this, "processUpdatesQueue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Mutex()
+            value: new Queue()
         });
-        Object.defineProperty(this, "updateGapRecoveryMutex", {
+        Object.defineProperty(this, "handler", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Mutex()
+            value: (_upd, next) => {
+                next();
+            }
         });
         this.parseMode = params?.parseMode ?? ParseMode.None;
         this.appVersion = params?.appVersion ?? APP_VERSION;
@@ -219,6 +229,9 @@ export class Client extends ClientAbstract {
         this.publicKeys = params?.publicKeys;
         this.autoStart = params?.autoStart ?? true;
     }
+    propagateConnectionState(connectionState) {
+        return this.handler({ connectionState }, resolve);
+    }
     /**
      * Sets the DC and resets the auth key stored in the session provider
      * if the stored DC was not the same as the `dc` parameter.
@@ -248,38 +261,47 @@ export class Client extends ClientAbstract {
      * Before establishing the connection, the session is saved.
      */
     async connect() {
-        if (!this.storageInited) {
-            await this.storage.init();
-            this.storageInited = true;
-        }
-        const authKey = await this.storage.getAuthKey();
-        if (authKey == null) {
-            const plain = new ClientPlain(this.transportProvider, this.publicKeys);
+        const release = await this.connectMutex.acquire();
+        try {
+            if (this.connected) {
+                return;
+            }
+            if (!this.storageInited) {
+                await this.storage.init();
+                this.storageInited = true;
+            }
+            const authKey = await this.storage.getAuthKey();
+            if (authKey == null) {
+                const plain = new ClientPlain({ initialDc: this.initialDc, transportProvider: this.transportProvider, cdn: this.cdn, publicKeys: this.publicKeys });
+                const dc = await this.storage.getDc();
+                if (dc != null) {
+                    plain.setDc(dc);
+                }
+                await plain.connect();
+                const { authKey, salt } = await plain.createAuthKey();
+                await plain.disconnect();
+                await this.storage.setAuthKey(authKey);
+                await this.setAuth(authKey);
+                this.state.salt = salt;
+            }
+            else {
+                await this.setAuth(authKey);
+            }
             const dc = await this.storage.getDc();
             if (dc != null) {
-                plain.setDc(dc);
+                await this.setDc(dc);
             }
-            await plain.connect();
-            const { authKey, salt } = await plain.createAuthKey();
-            await plain.disconnect();
-            await this.storage.setAuthKey(authKey);
-            await this.setAuth(authKey);
-            this.state.salt = salt;
-        }
-        else {
-            await this.setAuth(authKey);
-        }
-        const dc = await this.storage.getDc();
-        if (dc != null) {
-            await this.setDc(dc);
+            await super.connect();
+            if (dc == null) {
+                await this.storage.setDc(this.initialDc);
+            }
+            d("encrypted client connected");
+            drop(this.receiveLoop());
+            drop(this.pingLoop());
         }
-        await super.connect();
-        if (dc == null) {
-            await this.storage.setDc(this.transportProvider.initialDc);
+        finally {
+            release();
         }
-        d("encrypted client connected");
-        drop(this.receiveLoop());
-        drop(this.pingLoop());
     }
     async fetchState(source) {
         const state = await this.invoke(new functions.UpdatesGetState());
@@ -353,7 +375,7 @@ export class Client extends ClientAbstract {
                 params = mustPrompt("Bot token:");
             }
             else {
-                params = { phone: () => mustPrompt("Phone number:"), code: () => mustPrompt("Verification code:"), password: () => mustPrompt(`Password:`) };
+                params = { phone: () => mustPrompt("Phone number:"), code: () => mustPrompt("Verification code:"), password: () => mustPrompt("Password:") };
             }
         }
         dAuth("authorizing with %s", typeof params === "string" ? "bot token" : params instanceof types.AuthExportedAuthorization ? "exported authorization" : "AuthorizeUserParams");
@@ -513,7 +535,7 @@ export class Client extends ClientAbstract {
         await this.authorize(params);
     }
     async receiveLoop() {
-        if (!this.auth) {
+        if (!this.auth || !this.transport) {
             throw new Error("Not connected");
         }
         while (this.connected) {
@@ -522,7 +544,7 @@ export class Client extends ClientAbstract {
                     await this.send(new types.MsgsAck({ msgIds: [...this.toAcknowledge] }));
                     this.toAcknowledge.clear();
                 }
-                const buffer = await this.transport.receive();
+                const buffer = await this.transport.transport.receive();
                 let decrypted;
                 try {
                     decrypted = await (decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId));
@@ -539,8 +561,8 @@ export class Client extends ClientAbstract {
                         body = new TLReader(gunzip(body.packedData)).readObject();
                     }
                     dRecv("received %s", body.constructor.name);
-                    if (body instanceof types.Updates || body instanceof types.TypeUpdate) {
-                        drop(this.processUpdates(body));
+                    if (body instanceof types.TypeUpdates || body instanceof types.TypeUpdate) {
+                        this.processUpdatesQueue.add(() => this.processUpdates(body));
                     }
                     else if (message.body instanceof RPCResult) {
                         let result = message.body.result;
@@ -567,7 +589,10 @@ export class Client extends ClientAbstract {
                             }
                         };
                         if (result instanceof types.TypeUpdates || result instanceof types.TypeUpdate) {
-                            this.processUpdates(result).then(resolvePromise).catch();
+                            this.processUpdatesQueue.add(async () => {
+                                await this.processUpdates(result);
+                                resolvePromise();
+                            });
                         }
                         else {
                             await this.processResult(result);
@@ -619,7 +644,7 @@ export class Client extends ClientAbstract {
         }
     }
     async invoke(function_, noWait) {
-        if (!this.auth) {
+        if (!this.auth || !this.transport) {
             if (this.autoStart && !this.autoStarted) {
                 await this.start();
             }
@@ -627,7 +652,7 @@ export class Client extends ClientAbstract {
                 throw new Error("Not connected");
             }
         }
-        if (!this.auth) {
+        if (!this.auth || !this.transport) {
             UNREACHABLE();
         }
         let seqNo = this.state.seqNo * 2;
@@ -637,7 +662,7 @@ export class Client extends ClientAbstract {
         }
         const messageId = this.lastMsgId = getMessageId(this.lastMsgId);
         const message = new Message_(messageId, seqNo, function_);
-        await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
+        await this.transport.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
         d("invoked %s", function_.constructor.name);
         if (noWait) {
             return;
@@ -689,222 +714,160 @@ 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)) {
-                if (update.pts != 0 && update.ptsCount != 0) {
-                    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.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);
+    async checkGap(pts, ptsCount, assertNoGap) {
+        const localState = await this.getLocalState();
+        if (localState.pts + ptsCount < pts) {
+            if (assertNoGap) {
+                UNREACHABLE();
             }
-            if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateNewChannelMessage) {
-                if (update.message instanceof types.Message || update.message instanceof types.MessageService) {
-                    await this.storage.setMessage(peerToChatId(update.message.peerId), update.message.id, update.message);
-                }
+            else {
+                await this.recoverUpdateGap("processUpdates");
             }
-            else if (update instanceof types.UpdateDeleteChannelMessages) {
-                for (const message of update.messages) {
-                    await this.storage.setMessage(getChannelChatId(update.channelId), message, null);
-                }
+        }
+    }
+    async checkChannelGap(channelId, pts, ptsCount, assertNoGap) {
+        let localPts = await this.storage.getChannelPts(channelId);
+        if (!localPts) {
+            localPts = pts - ptsCount;
+        }
+        if (localPts + ptsCount < pts) {
+            if (assertNoGap) {
+                UNREACHABLE();
             }
-            else if (update instanceof types.UpdateDeleteMessages) {
-                for (const message of update.messages) {
-                    const chatId = await this.storage.getMessageChat(message);
-                    if (chatId) {
-                        await this.storage.setMessage(chatId, message, null);
-                    }
-                }
+            else {
+                await this.recoverChannelUpdateGap(channelId, "processUpdates");
             }
-            // 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();
+    async processUpdates(updates_, assertNoGap = false) {
+        /// First, individual updates (Update[1]) and updateShort* are extracted from Updates.[2]
+        ///
+        /// If an updatesTooLong[3] was received, an update gap recovery is initiated and no further action will be taken.
+        ///
+        /// [1]: https://core.telegram.org/type/Update
+        /// [2]: https://core.telegram.org/type/Updates
+        /// [3]: https://core.telegram.org/constructor/updatesTooLong
+        let updates;
+        if (updates_ instanceof types.UpdatesCombined || updates_ instanceof types.Updates) {
+            updates = updates_.updates;
+        }
+        else if (updates_ instanceof types.UpdateShort) {
+            updates = [updates_.update];
+        }
+        else if (updates_ instanceof types.UpdateShortMessage ||
+            updates_ instanceof types.UpdateShortChatMessage ||
+            updates_ instanceof types.UpdateShortSentMessage) {
+            updates = [updates_];
+        }
+        else if (updates_ instanceof types.UpdatesTooLong) {
+            await this.recoverUpdateGap("updatesTooLong");
+            return;
         }
-        if (update instanceof types.TypeUpdate && update instanceof types.UpdateChannelTooLong) {
-            // updateChannelTooLong is not applicable
-            UNREACHABLE();
+        else if (updates_ instanceof types.TypeUpdate) {
+            updates = [updates_];
         }
-        // can't apply updates when filling gap
-        const release = await this.updateGapRecoveryMutex.acquire();
-        try {
-            await this.applyUpdateNoGap(update);
-            release();
+        else {
+            UNREACHABLE();
         }
-        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.peerId[as](types.PeerChannel).channelId : update.channelId;
-                    await this.recoverChannelUpdateGap(channelId, "applyUpdate");
+        /// Then, we go through each Update and updateShort*, and see if they are order-sensitive.
+        /// If they were, we check the local state to see if it is OK to process them right away.
+        ///
+        /// If we there was a gap, a recovery process will be initiated and the processing will be postponed.
+        let localState = null;
+        let originalPts = null;
+        const channelPtsMap = new Map();
+        for (const update of updates) {
+            if (hasPts(update)) {
+                if (update.pts == 0) {
+                    continue;
                 }
-                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");
+                await this.checkGap(update.pts, update.ptsCount, assertNoGap);
+                localState ??= await this.getLocalState();
+                originalPts ??= localState.pts;
+                if (localState.pts + update.ptsCount > update.pts) {
+                    updates = updates.filter((v) => v != update);
                 }
                 else {
-                    // can't detect update gap from other types of updates
-                    UNREACHABLE();
+                    localState.pts = update.pts;
                 }
-                // just for integrity
-                const release = await this.updateGapRecoveryMutex.acquire();
-                try {
-                    await this.applyUpdateNoGap(update);
+            }
+            else if (hasChannelPts(update)) {
+                if (update.pts == 0) {
+                    continue;
                 }
-                catch (err) {
-                    if (err == UPDATE_GAP) {
-                        // the gap must have been filled until now
-                        UNREACHABLE();
-                    }
-                    else {
-                        throw err;
-                    }
+                const ptsCount = "ptsCount" in update ? update.ptsCount : 1;
+                const channelId = update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage ? update.message.peerId[as](types.PeerChannel).channelId : update.channelId;
+                await this.checkChannelGap(channelId, update.pts, ptsCount, assertNoGap);
+                let currentPts = channelPtsMap.get(channelId);
+                if (currentPts === undefined) {
+                    currentPts = await this.storage.getChannelPts(channelId);
                 }
-                finally {
-                    release();
+                currentPts ??= update.pts;
+                if (currentPts + ptsCount > update.pts) {
+                    updates = updates.filter((v) => v != update);
+                }
+                else {
+                    channelPtsMap.set(channelId, update.pts);
                 }
             }
-            else {
-                throw err;
+        }
+        if (!assertNoGap) {
+            if (localState != null && originalPts != null && localState.pts != originalPts) {
+                await this.storage.setState(localState);
+            }
+            for (const [channelId, pts] of channelPtsMap.entries()) {
+                await this.storage.setChannelPts(channelId, pts);
             }
         }
-    }
-    async processUpdates(updates, release) {
-        release ??= await this.updateProcessLock.acquire();
-        try {
-            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, release);
-                    }
-                }
-                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, release);
-                    }
-                }
+        /// We process the updates when we are sure there is no gap.
+        if (updates_ instanceof types.Updates || updates_ instanceof types.UpdatesCombined) {
+            await this.processChats(updates_.chats);
+            await this.processUsers(updates_.users);
+            await this.setUpdateStateDate(updates_.date);
+        }
+        else if (updates_ instanceof types.UpdateShort) {
+            await this.setUpdateStateDate(updates_.date);
+        }
+        const updatesToHandle = new Array();
+        for (const update of updates) {
+            if (update instanceof types.UpdateShortMessage ||
+                update instanceof types.UpdateShortChatMessage ||
+                update instanceof types.UpdateShortSentMessage) {
+                await this.setUpdateStateDate(update.date);
             }
-            else if (updates instanceof types.TypeUpdate && updates instanceof types.UpdateChannelTooLong) {
-                if (updates.pts != undefined) {
-                    await this.storage.setChannelPts(updates.channelId, updates.pts);
+            else if (update instanceof types.UpdateChannelTooLong) {
+                if (update.pts != undefined) {
+                    await this.storage.setChannelPts(update.channelId, update.pts);
                 }
-                await this.recoverChannelUpdateGap(updates.channelId, "updateChannelTooLong");
+                await this.recoverChannelUpdateGap(update.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 (update instanceof types.UpdateUserName) {
+                await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+            }
+            else if (update instanceof types.UpdatePtsChanged) {
+                await this.fetchState("updatePtsChanged");
+                if (this.updateState) {
+                    await this.storage.setState(this.updateState);
                 }
-                else if (updates instanceof types.UpdatePtsChanged) {
-                    await this.fetchState("updatePtsChanged");
-                    if (this.updateState) {
-                        await this.storage.setState(this.updateState);
-                    }
-                    else {
-                        UNREACHABLE();
-                    }
+                else {
+                    UNREACHABLE();
                 }
-                await this.applyUpdate(updates);
+            }
+            /// If there were any Update, they will be passed to the update handling queue.
+            if (update instanceof types.TypeUpdate) {
+                updatesToHandle.push(update);
             }
         }
-        catch (err) {
-            d("error processing updates: %O", err);
-        }
-        finally {
-            release();
-        }
+        this.handleUpdateQueue.add(async () => {
+            for (const update of updatesToHandle) {
+                await this.handleUpdate(update);
+            }
+        });
     }
     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();
-        }
+        const localState = await this.getLocalState();
+        localState.date = date;
+        await this.storage.setState(localState);
     }
     async getLocalState() {
         let localState = await this.storage.getState();
@@ -928,7 +891,7 @@ export class Client extends ClientAbstract {
     }
     async recoverUpdateGap(source) {
         dGap("recovering from update gap [%s]", source);
-        const release = await this.updateGapRecoveryMutex.acquire();
+        await this.propagateConnectionState("updating");
         try {
             let state = await this.getLocalState();
             while (true) {
@@ -937,10 +900,10 @@ export class Client extends ClientAbstract {
                     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 }));
+                        await this.processUpdates(new types.UpdateNewMessage({ message, pts: 0, ptsCount: 0 }), true);
                     }
                     for (const update of difference.otherUpdates) {
-                        await this.applyUpdateNoGap(update);
+                        await this.processUpdates(update, true);
                     }
                     if (difference instanceof types.UpdatesDifference) {
                         await this.storage.setState(difference.state[as](types.UpdatesState));
@@ -955,6 +918,7 @@ export class Client extends ClientAbstract {
                     }
                 }
                 else if (difference instanceof types.UpdatesDifferenceTooLong) {
+                    // TODO: we actually do now
                     // stored messages should be invalidated in case we store messages in the future
                     state.pts = difference.pts;
                     dGap("received differenceTooLong");
@@ -970,61 +934,55 @@ export class Client extends ClientAbstract {
             }
         }
         finally {
-            release();
+            this.stateChangeHandler(this.connected);
         }
     }
     async recoverChannelUpdateGap(channelId, source) {
         dGapC("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);
-                    dGapC("recovered from update gap [%o, %s]", channelId, source);
-                    break;
+        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.processUpdates(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
                 }
-                else if (difference instanceof types.UpdatesChannelDifferenceTooLong) {
-                    // invalidate messages
-                    dGapC("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();
-                    }
-                    dGapC("processed channelDifferenceTooLong");
+                for (const update of difference.otherUpdates) {
+                    await this.processUpdates(update, true);
                 }
-                else if (difference instanceof types.UpdatesChannelDifferenceEmpty) {
-                    dGapC("there was no update gap");
-                    break;
+                await this.storage.setChannelPts(channelId, difference.pts);
+                dGapC("recovered from update gap [%o, %s]", channelId, source);
+                break;
+            }
+            else if (difference instanceof types.UpdatesChannelDifferenceTooLong) {
+                // invalidate messages
+                dGapC("received channelDifferenceTooLong");
+                await this.processChats(difference.chats);
+                await this.processUsers(difference.users);
+                for (const message of difference.messages) {
+                    await this.processUpdates(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
+                }
+                const pts_ = difference.dialog[as](types.Dialog).pts;
+                if (pts_ != undefined) {
+                    pts = pts_;
+                }
+                else {
+                    UNREACHABLE();
                 }
+                dGapC("processed channelDifferenceTooLong");
+            }
+            else if (difference instanceof types.UpdatesChannelDifferenceEmpty) {
+                dGapC("there was no update gap");
+                break;
             }
-        }
-        finally {
-            release();
         }
     }
     async getInputPeer(id) {
@@ -1341,7 +1299,8 @@ export class Client extends ClientAbstract {
                 langPack: this.langPack,
                 systemLangCode: this.systemLangCode,
                 systemVersion: this.systemVersion,
-            }, true);
+                cdn: true,
+            });
             let dc = String(dcId);
             if (this.dcId < 0) {
                 dc += "-test";
@@ -1452,4 +1411,68 @@ export class Client extends ClientAbstract {
         }
         return constructUser(users[0][as](types.User));
     }
+    async handleUpdate(update) {
+        if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateNewChannelMessage) {
+            if (update.message instanceof types.Message || update.message instanceof types.MessageService) {
+                await this.storage.setMessage(peerToChatId(update.message.peerId), update.message.id, update.message);
+            }
+        }
+        else if (update instanceof types.UpdateDeleteChannelMessages) {
+            for (const message of update.messages) {
+                await this.storage.setMessage(getChannelChatId(update.channelId), message, null);
+            }
+        }
+        else if (update instanceof types.UpdateDeleteMessages) {
+            for (const message of update.messages) {
+                const chatId = await this.storage.getMessageChat(message);
+                if (chatId) {
+                    await this.storage.setMessage(chatId, message, null);
+                }
+            }
+        }
+        if (update instanceof types.UpdateNewMessage ||
+            update instanceof types.UpdateNewChannelMessage ||
+            update instanceof types.UpdateEditMessage ||
+            update instanceof types.UpdateEditChannelMessage) {
+            const key = update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage ? "message" : "editedMessage";
+            const message = await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this));
+            await this.handler({ [key]: message }, resolve);
+        }
+    }
+    use(middleware) {
+        const handler = this.handler;
+        this.handler = async (upd, next) => {
+            let called = false;
+            await middleware(upd, async () => {
+                if (called)
+                    return;
+                called = true;
+                await handler(upd, next);
+            });
+        };
+    }
+    on(filter, handler) {
+        const type = typeof filter === "string" ? filter : filter[0];
+        const keys = Array.isArray(filter) ? filter.slice(1) : [];
+        this.use((update, next) => {
+            if (type in update) {
+                if (keys.length > 0) {
+                    for (const key of keys) {
+                        // deno-lint-ignore ban-ts-comment
+                        // @ts-ignore
+                        if (!(key in update[type])) {
+                            return next();
+                        }
+                    }
+                }
+                // deno-lint-ignore ban-ts-comment
+                // @ts-ignore
+                return handler(update, next);
+            }
+            else {
+                return next();
+            }
+        });
+    }
 }
+const resolve = () => Promise.resolve();