@mtkruto/node 0.1.108 → 0.1.110

package/esm/client/4_client.js

@@ -1,3 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Client_instances, _a, _Client_auth, _Client_sessionId, _Client_state, _Client_promises, _Client_toAcknowledge, _Client_updateState, _Client_errorHandler, _Client_publicKeys, _Client_autoStart, _Client_propagateConnectionState, _Client_lastPropagatedConnectionState, _Client_storageInited, _Client_setAuth, _Client_authKeyWasCreated, _Client_connectMutex, _Client_assertUser, _Client_assertBot, _Client_fetchState, _Client_connectionInited, _Client_initConnection, _Client_lastPropagatedAuthorizationState, _Client_propagateAuthorizationState, _Client_selfId, _Client_getSelfId, _Client_receiveLoop, _Client_pingLoop, _Client_lastOutgoing, _Client_pingLoopStarted, _Client_autoStarted, _Client_lastMsgId, _Client_processChats, _Client_processUsers, _Client_handleUpdateQueue, _Client_processUpdatesQueue, _Client_checkChannelGap, _Client_processUpdates, _Client_setUpdateStateDate, _Client_getLocalState, _Client_recoverUpdateGap, _Client_recoverChannelUpdateGap, _Client_getChannelAccessHash, _Client_getInputPeerInner, _Client_updatesToMessages, _Client_resolveSendAs, _Client_parseText, _Client_getMessagesInner, _Client_downloadInner, _Client_handleUpdate, _Client_usernameResolver, _Client_constructReplyMarkup, _Client_assertMsgHas, _Client_handle, _Client_setMyInfo, _Client_getMyInfo;
 import { debug, gunzip, Mutex } from "../0_deps.js";
 import { bigIntFromBuffer, drop, getRandomBigInt, getRandomId, mod, mustPrompt, mustPromptOneOf, Queue, sha1, UNREACHABLE } from "../1_utilities.js";
 import { as, functions, getChannelChatId, Message_, MessageContainer, peerToChatId, RPCResult, TLError, TLReader, types } from "../2_tl.js";
@@ -35,6 +47,7 @@ export class Client extends ClientAbstract {
      */
     constructor(storage, apiId = 0, apiHash = "", params) {
         super(params);
+        _Client_instances.add(this);
         Object.defineProperty(this, "apiId", {
             enumerable: true,
             configurable: true,
@@ -47,48 +60,13 @@ export class Client extends ClientAbstract {
             writable: true,
             value: apiHash
         });
-        Object.defineProperty(this, "auth", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "sessionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: getRandomBigInt(8, true, false)
-        });
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: { salt: 0n, seqNo: 0 }
-        });
-        Object.defineProperty(this, "promises", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "toAcknowledge", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
-        Object.defineProperty(this, "updateState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "errorHandler", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+        _Client_auth.set(this, null);
+        _Client_sessionId.set(this, getRandomBigInt(8, true, false));
+        _Client_state.set(this, { salt: 0n, seqNo: 0 });
+        _Client_promises.set(this, new Map());
+        _Client_toAcknowledge.set(this, new Set());
+        _Client_updateState.set(this, void 0);
+        _Client_errorHandler.set(this, void 0);
         Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
@@ -137,35 +115,20 @@ export class Client extends ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "publicKeys", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "autoStart", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "lastPropagatedConnectionState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
+        _Client_publicKeys.set(this, void 0);
+        _Client_autoStart.set(this, void 0);
+        _Client_lastPropagatedConnectionState.set(this, null);
         Object.defineProperty(this, "stateChangeHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ((connected) => {
-                this.connectMutex.acquire().then(async (release) => {
+                __classPrivateFieldGet(this, _Client_connectMutex, "f").acquire().then(async (release) => {
                     try {
                         const connectionState = connected ? "ready" : "notConnected";
-                        if (this.connected == connected && this.lastPropagatedConnectionState != connectionState) {
-                            await this.propagateConnectionState(connectionState);
-                            this.lastPropagatedConnectionState = connectionState;
+                        if (this.connected == connected && __classPrivateFieldGet(this, _Client_lastPropagatedConnectionState, "f") != connectionState) {
+                            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, connectionState);
+                            __classPrivateFieldSet(this, _Client_lastPropagatedConnectionState, connectionState, "f");
                         }
                     }
                     finally {
@@ -174,81 +137,23 @@ export class Client extends ClientAbstract {
                 });
             }).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,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lastPropagatedAuthorizationState", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "selfId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "pingLoopStarted", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "autoStarted", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lastMsgId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0n
-        });
-        Object.defineProperty(this, "handleUpdateQueue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Queue("handleUpdate")
-        });
-        Object.defineProperty(this, "processUpdatesQueue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Queue("processUpdates")
-        });
-        Object.defineProperty(this, "usernameResolver", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (v) => {
-                const inputPeer = await this.getInputPeer(v).then((v) => v[as](types.InputPeerUser));
-                return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
-            }
-        });
-        Object.defineProperty(this, "handle", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: skip
+        _Client_storageInited.set(this, false);
+        _Client_authKeyWasCreated.set(this, true);
+        _Client_connectMutex.set(this, new Mutex());
+        _Client_connectionInited.set(this, false);
+        _Client_lastPropagatedAuthorizationState.set(this, null);
+        _Client_selfId.set(this, null);
+        _Client_lastOutgoing.set(this, null);
+        _Client_pingLoopStarted.set(this, false);
+        _Client_autoStarted.set(this, false);
+        _Client_lastMsgId.set(this, 0n);
+        _Client_handleUpdateQueue.set(this, new Queue("handleUpdate"));
+        _Client_processUpdatesQueue.set(this, new Queue("processUpdates"));
+        _Client_usernameResolver.set(this, async (v) => {
+            const inputPeer = await this.getInputPeer(v).then((v) => v[as](types.InputPeerUser));
+            return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
         });
+        _Client_handle.set(this, skip);
         this.storage = storage ?? new StorageMemory();
         this.parseMode = params?.parseMode ?? null;
         this.appVersion = params?.appVersion ?? APP_VERSION;
@@ -257,12 +162,9 @@ export class Client extends ClientAbstract {
         this.langPack = params?.langPack ?? LANG_PACK;
         this.systemLangCode = params?.systemLangCode ?? SYSTEM_LANG_CODE;
         this.systemVersion = params?.systemVersion ?? SYSTEM_VERSION;
-        this.publicKeys = params?.publicKeys;
-        this.autoStart = params?.autoStart ?? true;
-        this.errorHandler = params?.errorHandler;
-    }
-    propagateConnectionState(connectionState) {
-        return this.handle({ connectionState }, resolve);
+        __classPrivateFieldSet(this, _Client_publicKeys, params?.publicKeys, "f");
+        __classPrivateFieldSet(this, _Client_autoStart, params?.autoStart ?? true, "f");
+        __classPrivateFieldSet(this, _Client_errorHandler, params?.errorHandler, "f");
     }
     /**
      * Sets the DC and resets the auth key stored in the session provider
@@ -271,9 +173,9 @@ export class Client extends ClientAbstract {
      * @param dc The DC to change to.
      */
     async setDc(dc) {
-        if (!this.storageInited) {
+        if (!__classPrivateFieldGet(this, _Client_storageInited, "f")) {
             await this.storage.init();
-            this.storageInited = true;
+            __classPrivateFieldSet(this, _Client_storageInited, true, "f");
         }
         if (await this.storage.getDc() != dc) {
             await this.storage.setDc(dc);
@@ -282,11 +184,6 @@ export class Client extends ClientAbstract {
         }
         super.setDc(dc);
     }
-    async setAuth(key) {
-        const hash = await sha1(key);
-        const id = bigIntFromBuffer(hash.slice(-8), true, false);
-        this.auth = { key, id };
-    }
     /**
      * Loads the session if `setDc` was not called, initializes and connnects
      * a `ClientPlain` to generate auth key if there was none, and connects the client.
@@ -296,15 +193,15 @@ export class Client extends ClientAbstract {
         if (this.connected) {
             return;
         }
-        const release = await this.connectMutex.acquire();
+        const release = await __classPrivateFieldGet(this, _Client_connectMutex, "f").acquire();
         try {
-            if (!this.storageInited) {
+            if (!__classPrivateFieldGet(this, _Client_storageInited, "f")) {
                 await this.storage.init();
-                this.storageInited = true;
+                __classPrivateFieldSet(this, _Client_storageInited, true, "f");
             }
             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 plain = new ClientPlain({ initialDc: this.initialDc, transportProvider: this.transportProvider, cdn: this.cdn, publicKeys: __classPrivateFieldGet(this, _Client_publicKeys, "f") });
                 const dc = await this.storage.getDc();
                 if (dc != null) {
                     plain.setDc(dc);
@@ -313,11 +210,16 @@ export class Client extends ClientAbstract {
                 const { authKey, salt } = await plain.createAuthKey();
                 await plain.disconnect();
                 await this.storage.setAuthKey(authKey);
-                await this.setAuth(authKey);
-                this.state.salt = salt;
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setAuth).call(this, authKey);
+                __classPrivateFieldGet(this, _Client_state, "f").salt = salt;
+                await this.storage.setServerSalt(salt);
             }
             else {
-                await this.setAuth(authKey);
+                if (__classPrivateFieldGet(this, _Client_state, "f").salt == 0n) {
+                    __classPrivateFieldGet(this, _Client_state, "f").salt = await this.storage.getServerSalt() ?? 0n;
+                }
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setAuth).call(this, authKey);
+                __classPrivateFieldSet(this, _Client_authKeyWasCreated, false, "f");
             }
             const dc = await this.storage.getDc();
             if (dc != null) {
@@ -328,28 +230,31 @@ export class Client extends ClientAbstract {
                 await this.storage.setDc(this.initialDc);
             }
             d("encrypted client connected");
-            drop(this.receiveLoop());
+            drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_receiveLoop).call(this));
         }
         finally {
             release();
         }
     }
-    async assertUser(source) {
+    async [(_Client_auth = new WeakMap(), _Client_sessionId = new WeakMap(), _Client_state = new WeakMap(), _Client_promises = new WeakMap(), _Client_toAcknowledge = new WeakMap(), _Client_updateState = new WeakMap(), _Client_errorHandler = new WeakMap(), _Client_publicKeys = new WeakMap(), _Client_autoStart = new WeakMap(), _Client_lastPropagatedConnectionState = new WeakMap(), _Client_storageInited = new WeakMap(), _Client_authKeyWasCreated = new WeakMap(), _Client_connectMutex = new WeakMap(), _Client_connectionInited = new WeakMap(), _Client_lastPropagatedAuthorizationState = new WeakMap(), _Client_selfId = new WeakMap(), _Client_lastOutgoing = new WeakMap(), _Client_pingLoopStarted = new WeakMap(), _Client_autoStarted = new WeakMap(), _Client_lastMsgId = new WeakMap(), _Client_handleUpdateQueue = new WeakMap(), _Client_processUpdatesQueue = new WeakMap(), _Client_usernameResolver = new WeakMap(), _Client_handle = new WeakMap(), _Client_instances = new WeakSet(), _Client_propagateConnectionState = function _Client_propagateConnectionState(connectionState) {
+        return __classPrivateFieldGet(this, _Client_handle, "f").call(this, { connectionState }, resolve);
+    }, _Client_setAuth = async function _Client_setAuth(key) {
+        const hash = await sha1(key);
+        const id = bigIntFromBuffer(hash.slice(-8), true, false);
+        __classPrivateFieldSet(this, _Client_auth, { key, id }, "f");
+    }, _Client_assertUser = async function _Client_assertUser(source) {
         if (await this.storage.getAccountType() != "user") {
             throw new Error(`${source}: not user a client`);
         }
-    }
-    async assertBot(source) {
+    }, _Client_assertBot = async function _Client_assertBot(source) {
         if (await this.storage.getAccountType() != "bot") {
             throw new Error(`${source}: not a bot client`);
         }
-    }
-    async fetchState(source) {
+    }, _Client_fetchState = async function _Client_fetchState(source) {
         const state = await this.invoke(new functions.UpdatesGetState());
-        this.updateState = state;
+        __classPrivateFieldSet(this, _Client_updateState, state, "f");
         d("state fetched [%s]", source);
-    }
-    async [handleMigrationError](err) {
+    }, handleMigrationError)](err) {
         let newDc = String(err.dc);
         if (Math.abs(this.dcId) >= 10000) {
             newDc += "-test";
@@ -358,40 +263,9 @@ export class Client extends ClientAbstract {
         d("migrated to DC%s", newDc);
     }
     disconnect() {
-        this.connectionInited = false;
+        __classPrivateFieldSet(this, _Client_connectionInited, false, "f");
         return super.disconnect();
     }
-    async initConnection() {
-        if (!this.connectionInited) {
-            await this.invoke(new functions.InitConnection({
-                apiId: this.apiId,
-                appVersion: this.appVersion,
-                deviceModel: this.deviceModel,
-                langCode: this.langCode,
-                langPack: this.langPack,
-                query: new functions.InvokeWithLayer({
-                    layer: LAYER,
-                    query: new functions.HelpGetConfig(),
-                }),
-                systemLangCode: this.systemLangCode,
-                systemVersion: this.systemVersion,
-            }));
-            this.connectionInited = true;
-            d("connection inited");
-        }
-    }
-    async propagateAuthorizationState(authorized) {
-        if (this.lastPropagatedAuthorizationState != authorized) {
-            await this.handle({ authorizationState: { authorized } }, resolve);
-            this.lastPropagatedAuthorizationState = authorized;
-        }
-    }
-    async getSelfId() {
-        if (this.selfId == null) {
-            this.selfId = await this.getMe().then((v) => v.id);
-        }
-        return this.selfId;
-    }
     /**
      * Calls [initConnection](1) and authorizes the client with one of the following:
      *
@@ -426,10 +300,10 @@ export class Client extends ClientAbstract {
             }
         }
         dAuth("authorizing with %s", typeof params === "string" ? "bot token" : params instanceof types.AuthExportedAuthorization ? "exported authorization" : "AuthorizeUserParams");
-        await this.initConnection();
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_initConnection).call(this);
         try {
-            await this.fetchState("authorize");
-            await this.propagateAuthorizationState(true);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "authorize");
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, true);
             d("already authorized");
             return;
         }
@@ -442,14 +316,14 @@ export class Client extends ClientAbstract {
             while (true) {
                 try {
                     const auth = await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
-                    this.selfId = Number(auth[as](types.AuthAuthorization).user.id);
+                    __classPrivateFieldSet(this, _Client_selfId, Number(auth[as](types.AuthAuthorization).user.id), "f");
                     await this.storage.setAccountType("bot");
                     break;
                 }
                 catch (err) {
                     if (err instanceof Migrate) {
                         await this[handleMigrationError](err);
-                        await this.initConnection();
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_initConnection).call(this);
                         continue;
                     }
                     else {
@@ -458,8 +332,8 @@ export class Client extends ClientAbstract {
                 }
             }
             dAuth("authorized as bot");
-            await this.propagateAuthorizationState(true);
-            await this.fetchState("authorize");
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, true);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "authorize");
             return;
         }
         if (params instanceof types.AuthExportedAuthorization) {
@@ -467,89 +341,187 @@ export class Client extends ClientAbstract {
             dAuth("authorization imported");
             return;
         }
-        let phone;
-        let sentCode;
-        while (true) {
+        auth: while (true) {
             try {
-                phone = typeof params.phone === "string" ? params.phone : await params.phone();
-                const sendCode = () => this.invoke(new functions.AuthSendCode({
-                    phoneNumber: phone,
-                    apiId: this.apiId,
-                    apiHash: this.apiHash,
-                    settings: new types.CodeSettings(),
-                })).then((v) => v[as](types.AuthSentCode));
-                try {
-                    sentCode = await sendCode();
+                let phone;
+                let sentCode;
+                while (true) {
+                    try {
+                        phone = typeof params.phone === "string" ? params.phone : await params.phone();
+                        const sendCode = () => this.invoke(new functions.AuthSendCode({
+                            phoneNumber: phone,
+                            apiId: this.apiId,
+                            apiHash: this.apiHash,
+                            settings: new types.CodeSettings(),
+                        })).then((v) => v[as](types.AuthSentCode));
+                        try {
+                            sentCode = await sendCode();
+                        }
+                        catch (err) {
+                            if (err instanceof Migrate) {
+                                await this[handleMigrationError](err);
+                                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_initConnection).call(this);
+                                sentCode = await sendCode();
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                        break;
+                    }
+                    catch (err) {
+                        if (err instanceof PhoneNumberInvalid) {
+                            continue;
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
                 }
-                catch (err) {
-                    if (err instanceof Migrate) {
-                        await this[handleMigrationError](err);
-                        await this.initConnection();
-                        sentCode = await sendCode();
+                dAuth("verification code sent");
+                let err;
+                code: while (true) {
+                    const code = typeof params.code === "string" ? params.code : await params.code();
+                    try {
+                        const auth = await this.invoke(new functions.AuthSignIn({
+                            phoneNumber: phone,
+                            phoneCode: code,
+                            phoneCodeHash: sentCode.phoneCodeHash,
+                        }));
+                        __classPrivateFieldSet(this, _Client_selfId, Number(auth[as](types.AuthAuthorization).user.id), "f");
+                        await this.storage.setAccountType("user");
+                        dAuth("authorized as user");
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, true);
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "authorize");
+                        return;
                     }
-                    else {
-                        throw err;
+                    catch (err_) {
+                        if (err_ instanceof types.RPCError && err_.errorMessage == "PHONE_CODE_INVALID") {
+                            continue code;
+                        }
+                        else {
+                            err = err_;
+                            break code;
+                        }
+                    }
+                }
+                if (!(err instanceof SessionPasswordNeeded)) {
+                    throw err;
+                }
+                password: while (true) {
+                    const ap = await this.invoke(new functions.AccountGetPassword());
+                    if (!(ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow)) {
+                        throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
+                    }
+                    try {
+                        const password = typeof params.password === "string" ? params.password : await params.password(ap.hint ?? null);
+                        const input = await checkPassword(password, ap);
+                        const auth = await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                        __classPrivateFieldSet(this, _Client_selfId, Number(auth[as](types.AuthAuthorization).user.id), "f");
+                        await this.storage.setAccountType("user");
+                        dAuth("authorized as user");
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, true);
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "authorize");
+                        break password;
+                    }
+                    catch (err) {
+                        if (err instanceof PasswordHashInvalid) {
+                            continue password;
+                        }
+                        else {
+                            throw err;
+                        }
                     }
                 }
-                break;
             }
             catch (err) {
-                if (err instanceof PhoneNumberInvalid) {
-                    continue;
+                if (err == restartAuth) {
+                    continue auth;
                 }
                 else {
                     throw err;
                 }
             }
         }
-        dAuth("verification code sent");
-        let err;
-        while (true) {
-            const code = typeof params.code === "string" ? params.code : await params.code();
-            try {
-                const auth = await this.invoke(new functions.AuthSignIn({
-                    phoneNumber: phone,
-                    phoneCode: code,
-                    phoneCodeHash: sentCode.phoneCodeHash,
-                }));
-                this.selfId = Number(auth[as](types.AuthAuthorization).user.id);
-                await this.storage.setAccountType("user");
-                dAuth("authorized as user");
-                await this.propagateAuthorizationState(true);
-                await this.fetchState("authorize");
-                return;
-            }
-            catch (err_) {
-                if (err_ instanceof types.RPCError && err_.errorMessage == "PHONE_CODE_INVALID") {
-                    continue;
-                }
-                else {
-                    err = err_;
-                    break;
-                }
+    }
+    /**
+     * Same as calling `.connect()` followed by `.authorize(params)` if the session didn't have an auth key.
+     */
+    async start(params) {
+        await this.connect();
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_initConnection).call(this);
+        if (!__classPrivateFieldGet(this, _Client_authKeyWasCreated, "f")) {
+            return;
+        }
+        try {
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "authorize");
+            d("already authorized");
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, true);
+            return;
+        }
+        catch (err) {
+            if (!(err instanceof AuthKeyUnregistered)) {
+                throw err;
+            }
+        }
+        await this.authorize(params);
+    }
+    async invoke(function_, noWait) {
+        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
+            if (__classPrivateFieldGet(this, _Client_autoStart, "f") && !__classPrivateFieldGet(this, _Client_autoStarted, "f")) {
+                await this.start();
+            }
+            else {
+                throw new ConnectionError("Not connected");
             }
         }
-        if (!(err instanceof SessionPasswordNeeded)) {
-            throw err;
+        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
+            UNREACHABLE();
         }
+        let n = 1;
         while (true) {
-            const ap = await this.invoke(new functions.AccountGetPassword());
-            if (!(ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow)) {
-                throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
-            }
             try {
-                const password = typeof params.password === "string" ? params.password : await params.password(ap.hint ?? null);
-                const input = await checkPassword(password, ap);
-                const auth = await this.invoke(new functions.AuthCheckPassword({ password: input }));
-                this.selfId = Number(auth[as](types.AuthAuthorization).user.id);
-                await this.storage.setAccountType("user");
-                dAuth("authorized as user");
-                await this.propagateAuthorizationState(true);
-                await this.fetchState("authorize");
-                break;
+                let seqNo = __classPrivateFieldGet(this, _Client_state, "f").seqNo * 2;
+                if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
+                    seqNo++;
+                    __classPrivateFieldGet(this, _Client_state, "f").seqNo++;
+                }
+                const messageId = __classPrivateFieldSet(this, _Client_lastMsgId, getMessageId(__classPrivateFieldGet(this, _Client_lastMsgId, "f")), "f");
+                const message = new Message_(messageId, seqNo, function_);
+                await this.transport.transport.send(await encryptMessage(message, __classPrivateFieldGet(this, _Client_auth, "f").key, __classPrivateFieldGet(this, _Client_auth, "f").id, __classPrivateFieldGet(this, _Client_state, "f").salt, __classPrivateFieldGet(this, _Client_sessionId, "f")));
+                __classPrivateFieldSet(this, _Client_lastOutgoing, new Date(), "f");
+                d("invoked %s", function_.constructor.name);
+                if (noWait) {
+                    return;
+                }
+                let result;
+                try {
+                    result = await new Promise((resolve, reject) => {
+                        __classPrivateFieldGet(this, _Client_promises, "f").set(message.id, { resolve, reject });
+                    });
+                }
+                catch (err) {
+                    if (err instanceof AuthKeyUnregistered) {
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateAuthorizationState).call(this, false);
+                    }
+                    throw err;
+                }
+                if (result instanceof types.BadServerSalt) {
+                    return await this.invoke(function_);
+                }
+                else {
+                    if (!__classPrivateFieldGet(this, _Client_pingLoopStarted, "f")) {
+                        drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_pingLoop).call(this));
+                        __classPrivateFieldSet(this, _Client_pingLoopStarted, true, "f");
+                    }
+                    return result;
+                }
             }
             catch (err) {
-                if (err instanceof PasswordHashInvalid) {
+                if (__classPrivateFieldGet(this, _Client_errorHandler, "f") === undefined) {
+                    throw err;
+                }
+                if (__classPrivateFieldGet(this, _Client_errorHandler, "f") !== undefined && await __classPrivateFieldGet(this, _Client_errorHandler, "f").call(this, err, function_, n++)) {
                     continue;
                 }
                 else {
@@ -559,42 +531,85 @@ export class Client extends ClientAbstract {
         }
     }
     /**
-     * Same as calling `.connect()` followed by `.authorize(params)`.
+     * Alias for `invoke` with its second parameter being `true`.
      */
-    async start(params) {
-        await this.connect();
-        await this.initConnection();
-        try {
-            await this.fetchState("authorize");
-            d("already authorized");
-            await this.propagateAuthorizationState(true);
-            return;
+    send(function_) {
+        return this.invoke(function_, true);
+    }
+    async checkGap(pts, ptsCount, assertNoGap) {
+        const localState = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getLocalState).call(this);
+        if (localState.pts + ptsCount < pts) {
+            if (assertNoGap) {
+                UNREACHABLE();
+            }
+            else {
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverUpdateGap).call(this, "processUpdates");
+            }
         }
-        catch (err) {
-            if (!(err instanceof AuthKeyUnregistered)) {
-                throw err;
+    }
+    async getUserAccessHash(userId) {
+        const users = await this.invoke(new functions.UsersGetUsers({ id: [new types.InputUser({ userId, accessHash: 0n })] }));
+        return users[0][as](types.User).accessHash ?? 0n;
+    }
+    async getInputPeer(id) {
+        const inputPeer = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getInputPeerInner).call(this, id);
+        if (inputPeer instanceof types.InputPeerUser || inputPeer instanceof types.InputPeerChannel && inputPeer.accessHash == 0n && await this.storage.getAccountType() == "bot") {
+            if ("channelId" in inputPeer) {
+                inputPeer.accessHash = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getChannelAccessHash).call(this, inputPeer.channelId);
+            }
+            else {
+                inputPeer.accessHash = await this.getUserAccessHash(inputPeer.userId);
+                await this.storage.setUserAccessHash(inputPeer.userId, inputPeer.accessHash);
             }
         }
-        await this.authorize(params);
+        return inputPeer;
     }
-    async receiveLoop() {
-        if (!this.auth || !this.transport) {
+    [(_Client_initConnection = async function _Client_initConnection() {
+        if (!__classPrivateFieldGet(this, _Client_connectionInited, "f")) {
+            await this.invoke(new functions.InitConnection({
+                apiId: this.apiId,
+                appVersion: this.appVersion,
+                deviceModel: this.deviceModel,
+                langCode: this.langCode,
+                langPack: this.langPack,
+                query: new functions.InvokeWithLayer({
+                    layer: LAYER,
+                    query: new functions.HelpGetConfig(),
+                }),
+                systemLangCode: this.systemLangCode,
+                systemVersion: this.systemVersion,
+            }));
+            __classPrivateFieldSet(this, _Client_connectionInited, true, "f");
+            d("connection inited");
+        }
+    }, _Client_propagateAuthorizationState = async function _Client_propagateAuthorizationState(authorized) {
+        if (__classPrivateFieldGet(this, _Client_lastPropagatedAuthorizationState, "f") != authorized) {
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { authorizationState: { authorized } }, resolve);
+            __classPrivateFieldSet(this, _Client_lastPropagatedAuthorizationState, authorized, "f");
+        }
+    }, _Client_getSelfId = async function _Client_getSelfId() {
+        if (__classPrivateFieldGet(this, _Client_selfId, "f") == null) {
+            __classPrivateFieldSet(this, _Client_selfId, await this.getMe().then((v) => v.id), "f");
+        }
+        return __classPrivateFieldGet(this, _Client_selfId, "f");
+    }, _Client_receiveLoop = async function _Client_receiveLoop() {
+        if (!__classPrivateFieldGet(this, _Client_auth, "f") || !this.transport) {
             throw new ConnectionError("Not connected");
         }
         while (this.connected) {
             try {
-                if (this.toAcknowledge.size >= ACK_THRESHOLD) {
-                    await this.send(new types.MsgsAck({ msgIds: [...this.toAcknowledge] }));
-                    this.toAcknowledge.clear();
+                if (__classPrivateFieldGet(this, _Client_toAcknowledge, "f").size >= ACK_THRESHOLD) {
+                    await this.send(new types.MsgsAck({ msgIds: [...__classPrivateFieldGet(this, _Client_toAcknowledge, "f")] }));
+                    __classPrivateFieldGet(this, _Client_toAcknowledge, "f").clear();
                 }
                 const buffer = await this.transport.transport.receive();
                 let decrypted;
                 try {
-                    decrypted = await (decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId));
+                    decrypted = await (decryptMessage(buffer, __classPrivateFieldGet(this, _Client_auth, "f").key, __classPrivateFieldGet(this, _Client_auth, "f").id, __classPrivateFieldGet(this, _Client_sessionId, "f")));
                 }
                 catch (err) {
                     dRecv("failed to decrypt message: %o", err);
-                    drop(this.recoverUpdateGap("decryption"));
+                    drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverUpdateGap).call(this, "decryption"));
                     continue;
                 }
                 const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
@@ -605,10 +620,11 @@ export class Client extends ClientAbstract {
                     }
                     dRecv("received %s", body.constructor.name);
                     if (body instanceof types._TypeUpdates || body instanceof types._TypeUpdate) {
-                        this.processUpdatesQueue.add(() => this.processUpdates(body));
+                        __classPrivateFieldGet(this, _Client_processUpdatesQueue, "f").add(() => __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, body));
                     }
                     else if (body instanceof types.NewSessionCreated) {
-                        this.state.salt = body.serverSalt;
+                        __classPrivateFieldGet(this, _Client_state, "f").salt = body.serverSalt;
+                        await this.storage.setServerSalt(__classPrivateFieldGet(this, _Client_state, "f").salt);
                     }
                     else if (message.body instanceof RPCResult) {
                         let result = message.body.result;
@@ -623,7 +639,7 @@ export class Client extends ClientAbstract {
                         }
                         const messageId = message.body.messageId;
                         const resolvePromise = () => {
-                            const promise = this.promises.get(messageId);
+                            const promise = __classPrivateFieldGet(this, _Client_promises, "f").get(messageId);
                             if (promise) {
                                 if (result instanceof types.RPCError) {
                                     promise.reject(upgradeInstance(result));
@@ -631,12 +647,12 @@ export class Client extends ClientAbstract {
                                 else {
                                     promise.resolve(result);
                                 }
-                                this.promises.delete(messageId);
+                                __classPrivateFieldGet(this, _Client_promises, "f").delete(messageId);
                             }
                         };
                         if (result instanceof types._TypeUpdates || result instanceof types._TypeUpdate) {
-                            this.processUpdatesQueue.add(async () => {
-                                await this.processUpdates(result);
+                            __classPrivateFieldGet(this, _Client_processUpdatesQueue, "f").add(async () => {
+                                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, result);
                                 resolvePromise();
                             });
                         }
@@ -646,22 +662,23 @@ export class Client extends ClientAbstract {
                         }
                     }
                     else if (message.body instanceof types.Pong) {
-                        const promise = this.promises.get(message.body.msgId);
+                        const promise = __classPrivateFieldGet(this, _Client_promises, "f").get(message.body.msgId);
                         if (promise) {
                             promise.resolve(message.body);
-                            this.promises.delete(message.body.msgId);
+                            __classPrivateFieldGet(this, _Client_promises, "f").delete(message.body.msgId);
                         }
                     }
                     else if (message.body instanceof types.BadServerSalt) {
                         d("server salt reassigned");
-                        this.state.salt = message.body.newServerSalt;
-                        const promise = this.promises.get(message.body.badMsgId);
+                        __classPrivateFieldGet(this, _Client_state, "f").salt = message.body.newServerSalt;
+                        await this.storage.setServerSalt(__classPrivateFieldGet(this, _Client_state, "f").salt);
+                        const promise = __classPrivateFieldGet(this, _Client_promises, "f").get(message.body.badMsgId);
                         if (promise) {
                             promise.resolve(message.body);
-                            this.promises.delete(message.body.badMsgId);
+                            __classPrivateFieldGet(this, _Client_promises, "f").delete(message.body.badMsgId);
                         }
                     }
-                    this.toAcknowledge.add(message.id);
+                    __classPrivateFieldGet(this, _Client_toAcknowledge, "f").add(message.id);
                 }
             }
             catch (err) {
@@ -670,7 +687,7 @@ export class Client extends ClientAbstract {
                 }
                 else if (err instanceof TLError) {
                     dRecv("failed to deserialize: %o", err);
-                    drop(this.recoverUpdateGap("deserialize"));
+                    drop(__classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverUpdateGap).call(this, "deserialize"));
                 }
                 else {
                     dRecv("uncaught error: %o", err);
@@ -678,95 +695,27 @@ export class Client extends ClientAbstract {
             }
         }
         if (!this.connected) {
-            for (const { reject } of this.promises.values()) {
+            for (const { reject } of __classPrivateFieldGet(this, _Client_promises, "f").values()) {
                 reject(new ConnectionError("Connection was closed"));
             }
         }
         else {
             UNREACHABLE();
         }
-    }
-    async pingLoop() {
+    }, _Client_pingLoop = async function _Client_pingLoop() {
         while (this.connected) {
-            try {
-                await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
-            }
-            catch (err) {
-                d("ping loop error: %o", err);
-            }
             await new Promise((r) => setTimeout(r, 60 * 1000));
-        }
-    }
-    async invoke(function_, noWait) {
-        if (!this.auth || !this.transport) {
-            if (this.autoStart && !this.autoStarted) {
-                await this.start();
-            }
-            else {
-                throw new ConnectionError("Not connected");
+            if (!__classPrivateFieldGet(this, _Client_lastOutgoing, "f") || (Date.now() - __classPrivateFieldGet(this, _Client_lastOutgoing, "f").getTime() < 60 * 1000)) {
+                continue;
             }
-        }
-        if (!this.auth || !this.transport) {
-            UNREACHABLE();
-        }
-        let n = 1;
-        while (true) {
             try {
-                let seqNo = this.state.seqNo * 2;
-                if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
-                    seqNo++;
-                    this.state.seqNo++;
-                }
-                const messageId = this.lastMsgId = getMessageId(this.lastMsgId);
-                const message = new Message_(messageId, seqNo, function_);
-                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;
-                }
-                let result;
-                try {
-                    result = await new Promise((resolve, reject) => {
-                        this.promises.set(message.id, { resolve, reject });
-                    });
-                }
-                catch (err) {
-                    if (err instanceof AuthKeyUnregistered) {
-                        await this.propagateAuthorizationState(false);
-                    }
-                    throw err;
-                }
-                if (result instanceof types.BadServerSalt) {
-                    return await this.invoke(function_);
-                }
-                else {
-                    if (!this.pingLoopStarted) {
-                        drop(this.pingLoop());
-                        this.pingLoopStarted = true;
-                    }
-                    return result;
-                }
+                await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
             }
             catch (err) {
-                if (this.errorHandler === undefined) {
-                    throw err;
-                }
-                if (this.errorHandler !== undefined && await this.errorHandler(err, function_, n++)) {
-                    continue;
-                }
-                else {
-                    throw err;
-                }
+                d("ping loop error: %o", err);
             }
         }
-    }
-    /**
-     * Alias for `invoke` with its second parameter being `true`.
-     */
-    send(function_) {
-        return this.invoke(function_, true);
-    }
-    async processChats(chats) {
+    }, _Client_processChats = async function _Client_processChats(chats) {
         for (const chat of chats) {
             if (chat instanceof types.Channel && chat.accessHash) {
                 await this.storage.setEntity(chat);
@@ -782,8 +731,7 @@ export class Client extends ClientAbstract {
                 await this.storage.setEntity(chat);
             }
         }
-    }
-    async processUsers(users) {
+    }, _Client_processUsers = async function _Client_processUsers(users) {
         for (const user of users) {
             if (user instanceof types.User && user.accessHash) {
                 await this.storage.setEntity(user);
@@ -796,19 +744,7 @@ export class Client extends ClientAbstract {
                 }
             }
         }
-    }
-    async checkGap(pts, ptsCount, assertNoGap) {
-        const localState = await this.getLocalState();
-        if (localState.pts + ptsCount < pts) {
-            if (assertNoGap) {
-                UNREACHABLE();
-            }
-            else {
-                await this.recoverUpdateGap("processUpdates");
-            }
-        }
-    }
-    async checkChannelGap(channelId, pts, ptsCount, assertNoGap) {
+    }, _Client_checkChannelGap = async function _Client_checkChannelGap(channelId, pts, ptsCount, assertNoGap) {
         let localPts = await this.storage.getChannelPts(channelId);
         if (!localPts) {
             localPts = pts - ptsCount;
@@ -818,11 +754,10 @@ export class Client extends ClientAbstract {
                 UNREACHABLE();
             }
             else {
-                await this.recoverChannelUpdateGap(channelId, "processUpdates");
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverChannelUpdateGap).call(this, channelId, "processUpdates");
             }
         }
-    }
-    async processUpdates(updates_, assertNoGap = false) {
+    }, _Client_processUpdates = async function _Client_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.
@@ -843,7 +778,7 @@ export class Client extends ClientAbstract {
             updates = [updates_];
         }
         else if (updates_ instanceof types.UpdatesTooLong) {
-            await this.recoverUpdateGap("updatesTooLong");
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverUpdateGap).call(this, "updatesTooLong");
             return;
         }
         else if (updates_ instanceof types._TypeUpdate) {
@@ -865,7 +800,7 @@ export class Client extends ClientAbstract {
                     continue;
                 }
                 await this.checkGap(update.pts, update.ptsCount, assertNoGap);
-                localState ??= await this.getLocalState();
+                localState ??= await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getLocalState).call(this);
                 originalPts ??= localState.pts;
                 if (localState.pts + update.ptsCount > update.pts) {
                     updates = updates.filter((v) => v != update);
@@ -878,9 +813,9 @@ export class Client extends ClientAbstract {
                 if (update.pts == 0) {
                     continue;
                 }
-                const ptsCount = "ptsCount" in update ? update.ptsCount : 1;
+                const ptsCount = update.ptsCount;
                 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);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_checkChannelGap).call(this, channelId, update.pts, ptsCount, assertNoGap);
                 let currentPts = channelPtsMap.get(channelId);
                 if (currentPts === undefined) {
                     currentPts = await this.storage.getChannelPts(channelId);
@@ -904,33 +839,33 @@ export class Client extends ClientAbstract {
         }
         /// 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);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, updates_.chats);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, updates_.users);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setUpdateStateDate).call(this, updates_.date);
         }
         else if (updates_ instanceof types.UpdateShort) {
-            await this.setUpdateStateDate(updates_.date);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setUpdateStateDate).call(this, 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);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setUpdateStateDate).call(this, update.date);
             }
             else if (update instanceof types.UpdateChannelTooLong) {
                 if (update.pts != undefined) {
                     await this.storage.setChannelPts(update.channelId, update.pts);
                 }
-                await this.recoverChannelUpdateGap(update.channelId, "updateChannelTooLong");
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_recoverChannelUpdateGap).call(this, update.channelId, "updateChannelTooLong");
             }
             else if (update instanceof types.UpdateUserName) {
                 await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v.username));
             }
             else if (update instanceof types.UpdatePtsChanged) {
-                await this.fetchState("updatePtsChanged");
-                if (this.updateState) {
-                    await this.storage.setState(this.updateState);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "updatePtsChanged");
+                if (__classPrivateFieldGet(this, _Client_updateState, "f")) {
+                    await this.storage.setState(__classPrivateFieldGet(this, _Client_updateState, "f"));
                 }
                 else {
                     UNREACHABLE();
@@ -941,28 +876,26 @@ export class Client extends ClientAbstract {
                 updatesToHandle.push(update);
             }
         }
-        this.handleUpdateQueue.add(async () => {
+        __classPrivateFieldGet(this, _Client_handleUpdateQueue, "f").add(async () => {
             for (const update of updatesToHandle) {
-                await this.handleUpdate(update);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_handleUpdate).call(this, update);
             }
         });
-    }
-    async setUpdateStateDate(date) {
-        const localState = await this.getLocalState();
+    }, _Client_setUpdateStateDate = async function _Client_setUpdateStateDate(date) {
+        const localState = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getLocalState).call(this);
         localState.date = date;
         await this.storage.setState(localState);
-    }
-    async getLocalState() {
+    }, _Client_getLocalState = async function _Client_getLocalState() {
         let localState = await this.storage.getState();
         if (!localState) {
-            if (this.updateState) {
-                localState = this.updateState;
+            if (__classPrivateFieldGet(this, _Client_updateState, "f")) {
+                localState = __classPrivateFieldGet(this, _Client_updateState, "f");
                 await this.storage.setState(localState);
             }
             else {
-                await this.fetchState("getLocalState");
-                if (this.updateState) {
-                    localState = this.updateState;
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_fetchState).call(this, "getLocalState");
+                if (__classPrivateFieldGet(this, _Client_updateState, "f")) {
+                    localState = __classPrivateFieldGet(this, _Client_updateState, "f");
                     await this.storage.setState(localState);
                 }
                 else {
@@ -971,22 +904,21 @@ export class Client extends ClientAbstract {
             }
         }
         return localState;
-    }
-    async recoverUpdateGap(source) {
+    }, _Client_recoverUpdateGap = async function _Client_recoverUpdateGap(source) {
         dGap("recovering from update gap [%s]", source);
-        await this.propagateConnectionState("updating");
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_propagateConnectionState).call(this, "updating");
         try {
-            let state = await this.getLocalState();
+            let state = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getLocalState).call(this);
             while (true) {
                 const difference = await this.invoke(new functions.UpdatesGetDifference({ pts: state.pts, date: state.date, qts: state.qts ?? 0 }));
                 if (difference instanceof types.UpdatesDifference || difference instanceof types.UpdatesDifferenceSlice) {
-                    await this.processChats(difference.chats);
-                    await this.processUsers(difference.users);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, difference.chats);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, difference.users);
                     for (const message of difference.newMessages) {
-                        await this.processUpdates(new types.UpdateNewMessage({ message, pts: 0, ptsCount: 0 }), true);
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, new types.UpdateNewMessage({ message, pts: 0, ptsCount: 0 }), true);
                     }
                     for (const update of difference.otherUpdates) {
-                        await this.processUpdates(update, true);
+                        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, update, true);
                     }
                     if (difference instanceof types.UpdatesDifference) {
                         await this.storage.setState(difference.state);
@@ -1006,7 +938,7 @@ export class Client extends ClientAbstract {
                     dGap("received differenceTooLong");
                 }
                 else if (difference instanceof types.UpdatesDifferenceEmpty) {
-                    await this.setUpdateStateDate(difference.date);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setUpdateStateDate).call(this, difference.date);
                     dGap("there was no update gap");
                     break;
                 }
@@ -1018,8 +950,7 @@ export class Client extends ClientAbstract {
         finally {
             this.stateChangeHandler(this.connected);
         }
-    }
-    async recoverChannelUpdateGap(channelId, source) {
+    }, _Client_recoverChannelUpdateGap = async function _Client_recoverChannelUpdateGap(channelId, source) {
         dGapC("recovering channel update gap [%o, %s]", channelId, source);
         const pts_ = await this.storage.getChannelPts(channelId);
         let pts = pts_ == null ? 1 : pts_;
@@ -1032,13 +963,13 @@ export class Client extends ClientAbstract {
                 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);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, difference.chats);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, difference.users);
                 for (const message of difference.newMessages) {
-                    await this.processUpdates(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
                 }
                 for (const update of difference.otherUpdates) {
-                    await this.processUpdates(update, true);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, update, true);
                 }
                 await this.storage.setChannelPts(channelId, difference.pts);
                 dGapC("recovered from update gap [%o, %s]", channelId, source);
@@ -1047,10 +978,10 @@ export class Client extends ClientAbstract {
             else if (difference instanceof types.UpdatesChannelDifferenceTooLong) {
                 // invalidate messages
                 dGapC("received channelDifferenceTooLong");
-                await this.processChats(difference.chats);
-                await this.processUsers(difference.users);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, difference.chats);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, difference.users);
                 for (const message of difference.messages) {
-                    await this.processUpdates(new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUpdates).call(this, new types.UpdateNewChannelMessage({ message, pts: 0, ptsCount: 0 }), true);
                 }
                 const pts_ = difference.dialog[as](types.Dialog).pts;
                 if (pts_ != undefined) {
@@ -1066,29 +997,10 @@ export class Client extends ClientAbstract {
                 break;
             }
         }
-    }
-    async getUserAccessHash(userId) {
-        const users = await this.invoke(new functions.UsersGetUsers({ id: [new types.InputUser({ userId, accessHash: 0n })] }));
-        return users[0][as](types.User).accessHash ?? 0n;
-    }
-    async getChannelAccessHash(channelId) {
+    }, _Client_getChannelAccessHash = async function _Client_getChannelAccessHash(channelId) {
         const channels = await this.invoke(new functions.ChannelsGetChannels({ id: [new types.InputChannel({ channelId, accessHash: 0n })] }));
         return channels.chats[0][as](types.Channel).accessHash ?? 0n;
-    }
-    async getInputPeer(id) {
-        const inputPeer = await this.getInputPeerInner(id);
-        if (inputPeer instanceof types.InputPeerUser || inputPeer instanceof types.InputPeerChannel && inputPeer.accessHash == 0n && await this.storage.getAccountType() == "bot") {
-            if ("channelId" in inputPeer) {
-                inputPeer.accessHash = await this.getChannelAccessHash(inputPeer.channelId);
-            }
-            else {
-                inputPeer.accessHash = await this.getUserAccessHash(inputPeer.userId);
-                await this.storage.setUserAccessHash(inputPeer.userId, inputPeer.accessHash);
-            }
-        }
-        return inputPeer;
-    }
-    async getInputPeerInner(id) {
+    }, _Client_getInputPeerInner = async function _Client_getInputPeerInner(id) {
         if (typeof id === "string") {
             if (!id.startsWith("@")) {
                 throw new Error("Expected username to start with @");
@@ -1112,8 +1024,8 @@ export class Client extends ClientAbstract {
                 }
                 else {
                     const resolved = await this.invoke(new functions.ContactsResolveUsername({ username: id }));
-                    await this.processChats(resolved.chats);
-                    await this.processUsers(resolved.users);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, resolved.chats);
+                    await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, resolved.users);
                     if (resolved.peer instanceof types.PeerUser) {
                         userId = resolved.peer.userId;
                     }
@@ -1153,8 +1065,7 @@ export class Client extends ClientAbstract {
         else {
             throw new Error("ID format unknown or not implemented");
         }
-    }
-    [getEntity](peer) {
+    }, 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);
@@ -1196,9 +1107,9 @@ export class Client extends ClientAbstract {
             result instanceof types.ChatlistsChatlistUpdates ||
             result instanceof types.MessagesChats ||
             result instanceof types.MessagesChatsSlice) {
-            await this.processChats(result.chats);
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processChats).call(this, result.chats);
             if ("users" in result) {
-                await this.processUsers(result.users);
+                await __classPrivateFieldGet(this, _Client_instances, "m", _Client_processUsers).call(this, result.users);
             }
         }
         if (result instanceof types.MessagesMessages) {
@@ -1209,33 +1120,6 @@ export class Client extends ClientAbstract {
             }
         }
     }
-    async updatesToMessages(chatId, updates) {
-        const messages = new Array();
-        if (updates instanceof types.Updates) {
-            for (const update of updates.updates) {
-                if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateEditMessage) {
-                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
-                }
-                else if (update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage) {
-                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
-                }
-            }
-        }
-        else if (updates instanceof types.UpdateShortSentMessage || updates instanceof types.UpdateShortSentMessage) {
-            const message = await this.getMessage(chatId, updates.id);
-            if (message != null) {
-                messages.push(message);
-            }
-        }
-        return messages;
-    }
-    async resolveSendAs(params) {
-        const sendAs = params?.sendAs;
-        if (sendAs !== undefined) {
-            await this.assertUser("sendAs");
-            return sendAs ? await this.getInputPeer(sendAs) : undefined;
-        }
-    }
     /**
      * Send a text message.
      *
@@ -1245,8 +1129,8 @@ export class Client extends ClientAbstract {
      * @returns The sent text message.
      */
     async sendMessage(chatId, text, params) {
-        const [message, entities] = this.parseText(text, params);
-        const replyMarkup = await this.constructReplyMarkup(params);
+        const [message, entities] = __classPrivateFieldGet(this, _Client_instances, "m", _Client_parseText).call(this, text, params);
+        const replyMarkup = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_constructReplyMarkup).call(this, params);
         const peer = await this.getInputPeer(chatId);
         const randomId = getRandomId();
         const noWebpage = params?.disableWebPagePreview ? true : undefined;
@@ -1254,7 +1138,7 @@ export class Client extends ClientAbstract {
         const noforwards = params?.protectContent ? true : undefined;
         const replyToMsgId = params?.replyToMessageId;
         const topMsgId = params?.messageThreadId;
-        const sendAs = await this.resolveSendAs(params);
+        const sendAs = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_resolveSendAs).call(this, params);
         const result = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
@@ -1267,28 +1151,8 @@ export class Client extends ClientAbstract {
             entities,
             replyMarkup,
         }));
-        const message_ = await this.updatesToMessages(chatId, result).then((v) => v[0]);
-        return Client.assertMsgHas(message_, "text");
-    }
-    parseText(text, params) {
-        const entities_ = params?.entities ?? [];
-        const parseMode = params?.parseMode ?? this.parseMode;
-        switch (parseMode) {
-            case null:
-                break;
-            case "HTML": {
-                const [newText, entitiesToPush] = parseHtml(text);
-                text = newText;
-                for (const entity of entitiesToPush) {
-                    entities_.push(entity);
-                }
-                break;
-            }
-            default:
-                UNREACHABLE();
-        }
-        const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-        return [text, entities];
+        const message_ = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return __classPrivateFieldGet(Client, _a, "m", _Client_assertMsgHas).call(Client, message_, "text");
     }
     /**
      * Edit a message's text.
@@ -1300,19 +1164,77 @@ export class Client extends ClientAbstract {
      * @returns The edited text message.
      */
     async editMessageText(chatId, messageId, text, params) {
-        const [message, entities] = this.parseText(text, params);
+        const [message, entities] = __classPrivateFieldGet(this, _Client_instances, "m", _Client_parseText).call(this, text, params);
         const result = await this.invoke(new functions.MessagesEditMessage({
             id: messageId,
             peer: await this.getInputPeer(chatId),
             entities,
             message,
             noWebpage: params?.disableWebPagePreview ? true : undefined,
-            replyMarkup: await this.constructReplyMarkup(params),
+            replyMarkup: await __classPrivateFieldGet(this, _Client_instances, "m", _Client_constructReplyMarkup).call(this, params),
         }));
-        const message_ = await this.updatesToMessages(chatId, result).then((v) => v[0]);
-        return Client.assertMsgHas(message_, "text");
+        const message_ = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return __classPrivateFieldGet(Client, _a, "m", _Client_assertMsgHas).call(Client, message_, "text");
+    }
+    /**
+     * Retrieve multiple messages.
+     *
+     * @method
+     * @param chatId The identifier of the chat to retrieve the messages from.
+     * @param messageIds The identifiers of the messages to retrieve.
+     * @example ```ts
+     * const message = await client.getMessages("@MTKruto", [210, 212]);
+     * ```
+     * @returns The retrieved messages.
+     */
+    async getMessages(chatId, messageIds) {
+        return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMessagesInner).call(this, chatId, messageIds).then((v) => v.map((v) => v.message));
     }
-    async getMessagesInner(chatId_, messageIds) {
+    async [(_Client_updatesToMessages = async function _Client_updatesToMessages(chatId, updates) {
+        const messages = new Array();
+        if (updates instanceof types.Updates) {
+            for (const update of updates.updates) {
+                if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateEditMessage) {
+                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+                }
+                else if (update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage) {
+                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+                }
+            }
+        }
+        else if (updates instanceof types.UpdateShortSentMessage || updates instanceof types.UpdateShortSentMessage) {
+            const message = await this.getMessage(chatId, updates.id);
+            if (message != null) {
+                messages.push(message);
+            }
+        }
+        return messages;
+    }, _Client_resolveSendAs = async function _Client_resolveSendAs(params) {
+        const sendAs = params?.sendAs;
+        if (sendAs !== undefined) {
+            await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertUser).call(this, "sendAs");
+            return sendAs ? await this.getInputPeer(sendAs) : undefined;
+        }
+    }, _Client_parseText = function _Client_parseText(text, params) {
+        const entities_ = params?.entities ?? [];
+        const parseMode = params?.parseMode ?? this.parseMode;
+        switch (parseMode) {
+            case null:
+                break;
+            case "HTML": {
+                const [newText, entitiesToPush] = parseHtml(text);
+                text = newText;
+                for (const entity of entitiesToPush) {
+                    entities_.push(entity);
+                }
+                break;
+            }
+            default:
+                UNREACHABLE();
+        }
+        const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
+        return [text, entities];
+    }, _Client_getMessagesInner = async function _Client_getMessagesInner(chatId_, messageIds) {
         const peer = await this.getInputPeer(chatId_);
         let messages_ = new Array();
         const chatId = peerToChatId(peer);
@@ -1348,23 +1270,8 @@ export class Client extends ClientAbstract {
             messages.push({ message, isReplyToMessage });
         }
         return messages;
-    }
-    /**
-     * Retrieve multiple messages.
-     *
-     * @method
-     * @param chatId The identifier of the chat to retrieve the messages from.
-     * @param messageIds The identifiers of the messages to retrieve.
-     * @example ```ts
-     * const message = await client.getMessages("@MTKruto", [210, 212]);
-     * ```
-     * @returns The retrieved messages.
-     */
-    async getMessages(chatId, messageIds) {
-        return await this.getMessagesInner(chatId, messageIds).then((v) => v.map((v) => v.message));
-    }
-    async [getMessageWithReply](chatId, messageId) {
-        const messages = await this.getMessagesInner(chatId, [messageId]);
+    }, getMessageWithReply)](chatId, messageId) {
+        const messages = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMessagesInner).call(this, chatId, [messageId]);
         return messages[0]?.message ?? null;
     }
     /**
@@ -1382,7 +1289,44 @@ export class Client extends ClientAbstract {
         const messages = await this.getMessages(chatId, [messageId]);
         return messages[0] ?? null;
     }
-    async *downloadInner(location, dcId, params) {
+    /**
+     * Download a file.
+     *
+     * @method
+     * @param fileId The identifier of the file to download.
+     * @example ```ts
+     * for await (const chunk of client.download(fileId, { chunkSize: 256 * 1024 })) {
+     *   await outFile.write(chunk);
+     * }
+     * ```
+     * @returns A generator yielding the contents of the file.
+     */
+    async download(fileId, params) {
+        const fileId_ = FileID.decode(fileId);
+        switch (fileId_.fileType) {
+            case FileType.ChatPhoto: {
+                const big = fileId_.params.thumbnailSource == ThumbnailSource.ChatPhotoBig;
+                const peer = await this.getInputPeer(fileId_.params.chatId);
+                const location = new types.InputPeerPhotoFileLocation({ big: big ? true : undefined, peer, photoId: fileId_.params.mediaId });
+                return __classPrivateFieldGet(this, _Client_instances, "m", _Client_downloadInner).call(this, location, fileId_.dcId, params);
+            }
+            case FileType.Photo: {
+                if (fileId_.params.mediaId == undefined || fileId_.params.accessHash == undefined || fileId_.params.fileReference == undefined || fileId_.params.thumbnailSize == undefined) {
+                    UNREACHABLE();
+                }
+                const location = new types.InputPhotoFileLocation({
+                    id: fileId_.params.mediaId,
+                    accessHash: fileId_.params.accessHash,
+                    fileReference: fileId_.params.fileReference,
+                    thumbSize: fileId_.params.thumbnailSize,
+                });
+                return __classPrivateFieldGet(this, _Client_instances, "m", _Client_downloadInner).call(this, location, fileId_.dcId, params);
+            }
+            default:
+                UNREACHABLE();
+        }
+    }
+    async [(_Client_downloadInner = async function* _Client_downloadInner(location, dcId, params) {
         const chunkSize = params?.chunkSize ?? 1024 * 1024;
         if (mod(chunkSize, 1024) != 0) {
             throw new Error("chunkSize must be divisible by 1024");
@@ -1422,45 +1366,7 @@ export class Client extends ClientAbstract {
                 UNREACHABLE();
             }
         }
-    }
-    /**
-     * Download a file.
-     *
-     * @method
-     * @param fileId The identifier of the file to download.
-     * @example ```ts
-     * for await (const chunk of client.download(fileId, { chunkSize: 256 * 1024 })) {
-     *   await outFile.write(chunk);
-     * }
-     * ```
-     * @returns A generator yielding the contents of the file.
-     */
-    async download(fileId, params) {
-        const fileId_ = FileID.decode(fileId);
-        switch (fileId_.fileType) {
-            case FileType.ChatPhoto: {
-                const big = fileId_.params.thumbnailSource == ThumbnailSource.ChatPhotoBig;
-                const peer = await this.getInputPeer(fileId_.params.chatId);
-                const location = new types.InputPeerPhotoFileLocation({ big: big ? true : undefined, peer, photoId: fileId_.params.mediaId });
-                return this.downloadInner(location, fileId_.dcId, params);
-            }
-            case FileType.Photo: {
-                if (fileId_.params.mediaId == undefined || fileId_.params.accessHash == undefined || fileId_.params.fileReference == undefined || fileId_.params.thumbnailSize == undefined) {
-                    UNREACHABLE();
-                }
-                const location = new types.InputPhotoFileLocation({
-                    id: fileId_.params.mediaId,
-                    accessHash: fileId_.params.accessHash,
-                    fileReference: fileId_.params.fileReference,
-                    thumbSize: fileId_.params.thumbnailSize,
-                });
-                return this.downloadInner(location, fileId_.dcId, params);
-            }
-            default:
-                UNREACHABLE();
-        }
-    }
-    async [getStickerSetName](inputStickerSet, hash = 0) {
+    }, getStickerSetName)](inputStickerSet, hash = 0) {
         const maybeStickerSetName = await this.storage.getStickerSetName(inputStickerSet.id, inputStickerSet.accessHash);
         if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < STICKER_SET_NAME_TTL) {
             return maybeStickerSetName[0];
@@ -1494,7 +1400,7 @@ export class Client extends ClientAbstract {
             dropAuthor: params?.dropSenderName || undefined,
             dropMediaCaptions: params?.dropCaption || undefined,
         }));
-        return await this.updatesToMessages(to, result);
+        return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_updatesToMessages).call(this, to, result);
     }
     /**
      * Forward a single message.
@@ -1520,102 +1426,6 @@ export class Client extends ClientAbstract {
         }
         return constructUser(users[0][as](types.User));
     }
-    // TODO: log errors
-    async handleUpdate(update) {
-        if (update instanceof types.UpdateShortMessage) {
-            update = new types.UpdateNewMessage({
-                message: new types.Message({
-                    out: update.out,
-                    mentioned: update.mentioned,
-                    mediaUnread: update.mediaUnread,
-                    silent: update.silent,
-                    id: update.id,
-                    fromId: update.out ? new types.PeerUser({ userId: await this.getSelfId().then(BigInt) }) : new types.PeerUser({ userId: update.userId }),
-                    peerId: new types.PeerChat({ chatId: update.userId }),
-                    message: update.message,
-                    date: update.date,
-                    fwdFrom: update.fwdFrom,
-                    viaBotId: update.viaBotId,
-                    replyTo: update.replyTo,
-                    entities: update.entities,
-                    ttlPeriod: update.ttlPeriod,
-                }),
-                pts: update.pts,
-                ptsCount: update.ptsCount,
-            });
-        }
-        else if (update instanceof types.UpdateShortChatMessage) {
-            update = new types.UpdateNewMessage({
-                message: new types.Message({
-                    out: update.out,
-                    mentioned: update.mentioned,
-                    mediaUnread: update.mediaUnread,
-                    silent: update.silent,
-                    id: update.id,
-                    fromId: new types.PeerUser({ userId: update.fromId }),
-                    peerId: new types.PeerChat({ chatId: update.chatId }),
-                    fwdFrom: update.fwdFrom,
-                    viaBotId: update.viaBotId,
-                    replyTo: update.replyTo,
-                    date: update.date,
-                    message: update.message,
-                    entities: update.entities,
-                    ttlPeriod: update.ttlPeriod,
-                }),
-                pts: update.pts,
-                ptsCount: update.ptsCount,
-            });
-        }
-        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);
-            }
-        }
-        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.handle({ [key]: message }, resolve);
-        }
-        if (update instanceof types.UpdateDeleteMessages) {
-            const deletedMessages = new Array();
-            for (const messageId of update.messages) {
-                const chatId = await this.storage.getMessageChat(messageId);
-                if (chatId) {
-                    const message = await this.storage.getMessage(chatId, messageId);
-                    if (message != null) {
-                        deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
-                    }
-                    await this.storage.setMessage(chatId, messageId, null);
-                }
-            }
-            if (deletedMessages.length > 0) {
-                await this.handle({ deletedMessages: deletedMessages }, resolve);
-            }
-        }
-        else if (update instanceof types.UpdateDeleteChannelMessages) {
-            const chatId = getChannelChatId(update.channelId);
-            const deletedMessages = new Array();
-            for (const messageId of update.messages) {
-                const message = await this.storage.getMessage(chatId, messageId);
-                if (message) {
-                    deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
-                }
-                await this.storage.setMessage(chatId, messageId, null);
-            }
-            if (deletedMessages.length > 0) {
-                await this.handle({ deletedMessages: deletedMessages }, resolve);
-            }
-        }
-        if (update instanceof types.UpdateBotCallbackQuery || update instanceof types.UpdateInlineBotCallbackQuery) {
-            await this.handle({ callbackQuery: await constructCallbackQuery(update, this[getEntity].bind(this), this[getMessageWithReply].bind(this)) }, resolve);
-        }
-        else if (update instanceof types.UpdateBotInlineQuery) {
-            await this.handle({ inlineQuery: await constructInlineQuery(update, this[getEntity].bind(this)) }, resolve);
-        }
-    }
     /**
      * Answer a callback query. Bot-only.
      *
@@ -1623,7 +1433,7 @@ export class Client extends ClientAbstract {
      * @param id ID of the callback query to answer.
      */
     async answerCallbackQuery(id, params) {
-        await this.assertBot("answerCallbackQuery");
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "answerCallbackQuery");
         await this.invoke(new functions.MessagesSetBotCallbackAnswer({
             queryId: BigInt(id),
             cacheTime: params?.cacheTime ?? 0,
@@ -1631,18 +1441,6 @@ export class Client extends ClientAbstract {
             alert: params?.alert ? true : undefined,
         }));
     }
-    async constructReplyMarkup(params) {
-        if (params?.replyMarkup) {
-            await this.assertBot("replyMarkup");
-            return replyMarkupToTlObject(params.replyMarkup, this.usernameResolver.bind(this));
-        }
-    }
-    static assertMsgHas(message, key) {
-        if (!(key in message) || message[key] === undefined) {
-            UNREACHABLE();
-        }
-        return message;
-    }
     /**
      * Send a poll.
      *
@@ -1660,9 +1458,9 @@ export class Client extends ClientAbstract {
         const replyToMsgId = params?.replyToMessageId;
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined; // TODO: check default sendAs
-        const replyMarkup = await this.constructReplyMarkup(params);
+        const replyMarkup = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_constructReplyMarkup).call(this, params);
         const explanation = params?.explanation;
-        const parseResult = explanation !== undefined ? this.parseText(explanation, { parseMode: params?.explanationParseMode, entities: params?.explanationEntities }) : undefined;
+        const parseResult = explanation !== undefined ? __classPrivateFieldGet(this, _Client_instances, "m", _Client_parseText).call(this, explanation, { parseMode: params?.explanationParseMode, entities: params?.explanationEntities }) : undefined;
         const solution = parseResult === undefined ? undefined : parseResult[0];
         const solutionEntities = parseResult === undefined ? undefined : parseResult[1];
         const answers = options.map((v, i) => new types.PollAnswer({ option: new Uint8Array([i]), text: v }));
@@ -1694,8 +1492,8 @@ export class Client extends ClientAbstract {
             media,
             message: "",
         }));
-        const message = await this.updatesToMessages(chatId, result).then((v) => v[0]);
-        return Client.assertMsgHas(message, "poll");
+        const message = await __classPrivateFieldGet(this, _Client_instances, "m", _Client_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return __classPrivateFieldGet(Client, _a, "m", _Client_assertMsgHas).call(Client, message, "poll");
     }
     /**
      * Send a chat action.
@@ -1775,7 +1573,7 @@ export class Client extends ClientAbstract {
             autoStart: false,
         });
         signal?.addEventListener("abort", () => drop(client.disconnect()));
-        client.state.salt = this.state.salt;
+        __classPrivateFieldGet(client, _Client_state, "f").salt = __classPrivateFieldGet(this, _Client_state, "f").salt;
         await client.connect();
         let part = 0;
         const partCount = Math.ceil(contents.length / chunkSize);
@@ -1870,7 +1668,7 @@ export class Client extends ClientAbstract {
     async answerInlineQuery(id, results, params) {
         await this.invoke(new functions.MessagesSetInlineBotResults({
             queryId: BigInt(id),
-            results: await Promise.all(results.map((v) => inlineQueryResultToTlObject(v, this.parseText.bind(this), this.usernameResolver.bind(this)))),
+            results: await Promise.all(results.map((v) => inlineQueryResultToTlObject(v, __classPrivateFieldGet(this, _Client_instances, "m", _Client_parseText).bind(this), __classPrivateFieldGet(this, _Client_usernameResolver, "f").bind(this)))),
             cacheTime: params?.cacheTime ?? 300,
             private: params?.isPersonal ? true : undefined,
             switchWebview: params?.button && params.button.webApp ? new types.InlineBotWebView({ text: params.button.text, url: params.button.webApp.url }) : undefined,
@@ -1880,8 +1678,8 @@ export class Client extends ClientAbstract {
         }));
     }
     use(handler) {
-        const handle = this.handle;
-        this.handle = async (upd, next) => {
+        const handle = __classPrivateFieldGet(this, _Client_handle, "f");
+        __classPrivateFieldSet(this, _Client_handle, async (upd, next) => {
             let called = false;
             await handle(upd, async () => {
                 if (called)
@@ -1889,7 +1687,7 @@ export class Client extends ClientAbstract {
                 called = true;
                 await handler(upd, next);
             });
-        };
+        }, "f");
     }
     branch(predicate, trueHandler, falseHandler) {
         this.use(async (upd, next) => {
@@ -1925,17 +1723,14 @@ export class Client extends ClientAbstract {
             }
         }, handler);
     }
-    async setMyInfo(info) {
-        await this.invoke(new functions.BotsSetBotInfo({ bot: new types.InputUserSelf(), ...info }));
-    }
     /**
      * Set the bot's description in the given language. Bot-only.
      *
      * @method
      */
     async setMyDescription({ description, languageCode }) {
-        await this.assertBot("setMyDescription");
-        await this.setMyInfo({ description, langCode: languageCode ?? "" });
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "setMyDescription");
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setMyInfo).call(this, { description, langCode: languageCode ?? "" });
     }
     /**
      * Set the bot's name in the given language. Bot-only.
@@ -1943,8 +1738,8 @@ export class Client extends ClientAbstract {
      * @method
      */
     async setMyName({ name, languageCode }) {
-        await this.assertBot("setMyName");
-        await this.setMyInfo({ name, langCode: languageCode ?? "" });
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "setMyName");
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setMyInfo).call(this, { name, langCode: languageCode ?? "" });
     }
     /**
      * Set the bot's short description in the given language. Bot-only.
@@ -1952,11 +1747,8 @@ export class Client extends ClientAbstract {
      * @method
      */
     async setMyShortDescription({ shortDescription: about, languageCode }) {
-        await this.assertBot("setMyShortDescription");
-        await this.setMyInfo({ about, langCode: languageCode ?? "" });
-    }
-    getMyInfo(languageCode) {
-        return this.invoke(new functions.BotsGetBotInfo({ bot: new types.InputUserSelf(), langCode: languageCode ?? "" }));
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "setMyShortDescription");
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_setMyInfo).call(this, { about, langCode: languageCode ?? "" });
     }
     /**
      * Get the bot's description in the given language. Bot-only.
@@ -1964,8 +1756,8 @@ export class Client extends ClientAbstract {
      * @method
      */
     async getMyDescription(params) {
-        await this.assertBot("getMyDescription");
-        return await this.getMyInfo(params?.languageCode).then((v) => v.description);
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "getMyDescription");
+        return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMyInfo).call(this, params?.languageCode).then((v) => v.description);
     }
     /**
      * Set the bot's name in the given language. Bot-only.
@@ -1973,8 +1765,8 @@ export class Client extends ClientAbstract {
      * @method
      */
     async getMyName(params) {
-        await this.assertBot("getMyName");
-        return await this.getMyInfo(params?.languageCode).then((v) => v.description);
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "getMyName");
+        return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMyInfo).call(this, params?.languageCode).then((v) => v.description);
     }
     /**
      * Get the bot's short description in the given language. Bot-only.
@@ -1982,7 +1774,118 @@ export class Client extends ClientAbstract {
      * @method
      */
     async getMyShortDescription(params) {
-        await this.assertBot("getMyShortDescription");
-        return await this.getMyInfo(params?.languageCode).then((v) => v.about);
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "getMyShortDescription");
+        return await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getMyInfo).call(this, params?.languageCode).then((v) => v.about);
     }
 }
+_a = Client, _Client_handleUpdate = 
+// TODO: log errors
+async function _Client_handleUpdate(update) {
+    if (update instanceof types.UpdateShortMessage) {
+        update = new types.UpdateNewMessage({
+            message: new types.Message({
+                out: update.out,
+                mentioned: update.mentioned,
+                mediaUnread: update.mediaUnread,
+                silent: update.silent,
+                id: update.id,
+                fromId: update.out ? new types.PeerUser({ userId: await __classPrivateFieldGet(this, _Client_instances, "m", _Client_getSelfId).call(this).then(BigInt) }) : new types.PeerUser({ userId: update.userId }),
+                peerId: new types.PeerChat({ chatId: update.userId }),
+                message: update.message,
+                date: update.date,
+                fwdFrom: update.fwdFrom,
+                viaBotId: update.viaBotId,
+                replyTo: update.replyTo,
+                entities: update.entities,
+                ttlPeriod: update.ttlPeriod,
+            }),
+            pts: update.pts,
+            ptsCount: update.ptsCount,
+        });
+    }
+    else if (update instanceof types.UpdateShortChatMessage) {
+        update = new types.UpdateNewMessage({
+            message: new types.Message({
+                out: update.out,
+                mentioned: update.mentioned,
+                mediaUnread: update.mediaUnread,
+                silent: update.silent,
+                id: update.id,
+                fromId: new types.PeerUser({ userId: update.fromId }),
+                peerId: new types.PeerChat({ chatId: update.chatId }),
+                fwdFrom: update.fwdFrom,
+                viaBotId: update.viaBotId,
+                replyTo: update.replyTo,
+                date: update.date,
+                message: update.message,
+                entities: update.entities,
+                ttlPeriod: update.ttlPeriod,
+            }),
+            pts: update.pts,
+            ptsCount: update.ptsCount,
+        });
+    }
+    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);
+        }
+    }
+    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 __classPrivateFieldGet(this, _Client_handle, "f").call(this, { [key]: message }, resolve);
+    }
+    if (update instanceof types.UpdateDeleteMessages) {
+        const deletedMessages = new Array();
+        for (const messageId of update.messages) {
+            const chatId = await this.storage.getMessageChat(messageId);
+            if (chatId) {
+                const message = await this.storage.getMessage(chatId, messageId);
+                if (message != null) {
+                    deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+                }
+                await this.storage.setMessage(chatId, messageId, null);
+            }
+        }
+        if (deletedMessages.length > 0) {
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { deletedMessages: deletedMessages }, resolve);
+        }
+    }
+    else if (update instanceof types.UpdateDeleteChannelMessages) {
+        const chatId = getChannelChatId(update.channelId);
+        const deletedMessages = new Array();
+        for (const messageId of update.messages) {
+            const message = await this.storage.getMessage(chatId, messageId);
+            if (message) {
+                deletedMessages.push(await constructMessage(message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+            }
+            await this.storage.setMessage(chatId, messageId, null);
+        }
+        if (deletedMessages.length > 0) {
+            await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { deletedMessages: deletedMessages }, resolve);
+        }
+    }
+    if (update instanceof types.UpdateBotCallbackQuery || update instanceof types.UpdateInlineBotCallbackQuery) {
+        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { callbackQuery: await constructCallbackQuery(update, this[getEntity].bind(this), this[getMessageWithReply].bind(this)) }, resolve);
+    }
+    else if (update instanceof types.UpdateBotInlineQuery) {
+        await __classPrivateFieldGet(this, _Client_handle, "f").call(this, { inlineQuery: await constructInlineQuery(update, this[getEntity].bind(this)) }, resolve);
+    }
+}, _Client_constructReplyMarkup = async function _Client_constructReplyMarkup(params) {
+    if (params?.replyMarkup) {
+        await __classPrivateFieldGet(this, _Client_instances, "m", _Client_assertBot).call(this, "replyMarkup");
+        return replyMarkupToTlObject(params.replyMarkup, __classPrivateFieldGet(this, _Client_usernameResolver, "f").bind(this));
+    }
+}, _Client_assertMsgHas = function _Client_assertMsgHas(message, key) {
+    if (!(key in message) || message[key] === undefined) {
+        UNREACHABLE();
+    }
+    return message;
+}, _Client_setMyInfo = async function _Client_setMyInfo(info) {
+    await this.invoke(new functions.BotsSetBotInfo({ bot: new types.InputUserSelf(), ...info }));
+}, _Client_getMyInfo = function _Client_getMyInfo(languageCode) {
+    return this.invoke(new functions.BotsGetBotInfo({ bot: new types.InputUserSelf(), langCode: languageCode ?? "" }));
+};