@mtkruto/node 0.1.170 → 0.1.183

package/esm/0_deps.d.ts

@@ -1,7 +1,7 @@
-export * from "./deps/deno.land/std@0.219.0/assert/mod.js";
-export * as path from "./deps/deno.land/std@0.219.0/path/mod.js";
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.219.0/encoding/base64.js";
-import { contentType as contentType_ } from "./deps/deno.land/std@0.219.0/media_types/content_type.js";
+export * from "./deps/deno.land/std@0.220.1/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.220.1/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.220.1/encoding/base64.js";
+import { contentType as contentType_ } from "./deps/deno.land/std@0.220.1/media_types/content_type.js";
 export declare const contentType: typeof contentType_;
 export declare function extension(mimeType: string): string;
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";

package/esm/0_deps.js

@@ -1,7 +1,7 @@
-export * from "./deps/deno.land/std@0.219.0/assert/mod.js";
-export * as path from "./deps/deno.land/std@0.219.0/path/mod.js";
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.219.0/encoding/base64.js";
-import { contentType as contentType_ } from "./deps/deno.land/std@0.219.0/media_types/content_type.js";
+export * from "./deps/deno.land/std@0.220.1/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.220.1/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.220.1/encoding/base64.js";
+import { contentType as contentType_ } from "./deps/deno.land/std@0.220.1/media_types/content_type.js";
 export const contentType = (extentionOrType) => {
     if (extentionOrType == "tgs") {
         return "application/x-tgsticker";
@@ -10,7 +10,7 @@ export const contentType = (extentionOrType) => {
         return contentType_(extentionOrType);
     }
 };
-import { extension as extension_ } from "./deps/deno.land/std@0.219.0/media_types/extension.js";
+import { extension as extension_ } from "./deps/deno.land/std@0.220.1/media_types/extension.js";
 export function extension(mimeType) {
     if (mimeType == "application/x-tgsticker") {
         return "tgs";

package/esm/4_constants.d.ts

@@ -1,10 +1,9 @@
 import { DC } from "./3_transport.js";
-export declare const ACK_THRESHOLD = 10;
 export type PublicKeys = readonly [bigint, [bigint, bigint]][];
 export declare const PUBLIC_KEYS: PublicKeys;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 176;
-export declare const APP_VERSION = "MTKruto 0.1.170";
+export declare const APP_VERSION = "MTKruto 0.1.180";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -1,5 +1,4 @@
 import * as dntShim from "./_dnt.shims.js";
-export const ACK_THRESHOLD = 10;
 export const PUBLIC_KEYS = Object.freeze([
     [
         1562291298945373506n,
@@ -53,9 +52,9 @@ export const PUBLIC_KEYS = Object.freeze([
 ]);
 export const INITIAL_DC = "2";
 export const LAYER = 176;
-export const APP_VERSION = "MTKruto 0.1.170";
+export const APP_VERSION = "MTKruto 0.1.180";
 // @ts-ignore: lib
-export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
+export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : (navigator.userAgent.split(" ")[0] || "Unknown") : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" || typeof navigator.language !== "string" ? "en" : navigator.language.split("-")[0];
 export const LANG_PACK = "";
 export const SYSTEM_LANG_CODE = LANG_CODE;

package/esm/5_client.d.ts

@@ -1,4 +1,4 @@
 export * from "./client/0_params.js";
-export * from "./client/2_client_plain.js";
+export * from "./client/1_client_plain.js";
+export * from "./client/1_client_encrypted.js";
 export * from "./client/4_client.js";
-export * from "./client/5_composer.js";

package/esm/5_client.js

@@ -1,4 +1,4 @@
 export * from "./client/0_params.js";
-export * from "./client/2_client_plain.js";
+export * from "./client/1_client_plain.js";
+export * from "./client/1_client_encrypted.js";
 export * from "./client/4_client.js";
-export * from "./client/5_composer.js";

package/esm/client/0_client_abstract.d.ts

@@ -16,16 +16,18 @@ export interface ClientAbstractParams {
 }
 export declare abstract class ClientAbstract {
     #private;
-    protected readonly initialDc: DC;
-    protected transportProvider: TransportProvider;
-    protected readonly cdn: boolean;
+    readonly initialDc: DC;
+    transportProvider: TransportProvider;
+    readonly cdn: boolean;
     protected transport?: ReturnType<TransportProvider>;
     constructor(params?: ClientAbstractParams);
-    protected stateChangeHandler?: (connected: boolean) => void;
+    stateChangeHandler?: (connected: boolean) => void;
+    get dc(): DC;
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
     get connected(): boolean;
     connect(): Promise<void>;
     reconnect(dc?: DC): Promise<void>;
     disconnect(): Promise<void>;
+    get disconnected(): boolean;
 }

package/esm/client/0_client_abstract.js

@@ -1,14 +1,14 @@
+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 __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 _ClientAbstract_dc;
 import { initTgCrypto } from "../0_deps.js";
 import { transportProviderWebSocket } from "../3_transport.js";
@@ -50,6 +50,9 @@ export class ClientAbstract {
         this.transportProvider = params?.transportProvider ?? transportProviderWebSocket();
         this.cdn = params?.cdn ?? false;
     }
+    get dc() {
+        return __classPrivateFieldGet(this, _ClientAbstract_dc, "f") ?? this.initialDc;
+    }
     get dcId() {
         if (!this.transport) {
             throw new Error("Not connected");
@@ -84,5 +87,8 @@ export class ClientAbstract {
         await this.transport.transport.deinitialize();
         await this.transport.connection.close();
     }
+    get disconnected() {
+        return !this.transport?.transport.initialized;
+    }
 }
 _ClientAbstract_dc = new WeakMap();

package/esm/client/0_message.d.ts

@@ -5,5 +5,5 @@ export declare function unpackUnencryptedMessage(buffer: Uint8Array): {
     messageId: bigint;
     message: Uint8Array;
 };
-export declare function encryptMessage(message: Message_, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
+export declare function encryptMessage(message: Message_ | MessageContainer, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
 export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message_ | MessageContainer>;

package/esm/client/0_message.js

@@ -29,14 +29,10 @@ export function unpackUnencryptedMessage(buffer) {
     return { messageId, message };
 }
 export async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
-    const encoded = message.body[serialize]();
     const payloadWriter = new TLWriter();
     payloadWriter.writeInt64(salt);
     payloadWriter.writeInt64(sessionId);
-    payloadWriter.writeInt64(message.id);
-    payloadWriter.writeInt32(message.seqNo);
-    payloadWriter.writeInt32(encoded.length);
-    payloadWriter.write(encoded);
+    payloadWriter.write(message[serialize]());
     payloadWriter.write(new Uint8Array(mod(-(payloadWriter.buffer.length + 12), 16) + 12));
     const payload = payloadWriter.buffer;
     const messageKey = (await sha256(concat(authKey.subarray(88, 120), payload))).subarray(8, 24);
@@ -70,7 +66,8 @@ export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
     plainReader = new TLReader(plainReader.read(length));
     const cid = plainReader.readInt32(false);
     if (cid == MessageContainer[id]) {
-        return MessageContainer.deserialize(plainReader.buffer);
+        const messages = MessageContainer.deserialize(plainReader.buffer);
+        return new MessageContainer(mid, seqno, messages);
     }
     else if (cid == RPCResult[id]) {
         const body = RPCResult.deserialize(plainReader.buffer);

package/esm/client/1_client_encrypted.d.ts

@@ -0,0 +1,34 @@
+import { enums, functions, ReadObject, TLObject, types } from "../2_tl.js";
+import { ClientAbstract } from "./0_client_abstract.js";
+import { ClientAbstractParams } from "./0_client_abstract.js";
+export type ErrorSource = "deserialization" | "decryption" | "unknown";
+export interface Handlers {
+    serverSaltReassigned?: (newServerSalt: bigint) => void;
+    updates?: (updates: enums.Updates | enums.Update, call: TLObject | null, callback?: () => void) => void;
+    result?: (result: ReadObject, callback: () => void) => void;
+    error?: (err: unknown, source: ErrorSource) => void;
+}
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+export declare class ClientEncrypted extends ClientAbstract {
+    #private;
+    handlers: Handlers;
+    constructor(params?: ClientAbstractParams);
+    connect(): Promise<void>;
+    setAuthKey(key: Uint8Array): Promise<void>;
+    get authKey(): Uint8Array;
+    set serverSalt(serverSalt: bigint);
+    get serverSalt(): bigint;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait?: boolean): Promise<T | void>;
+}

package/esm/client/1_client_encrypted.js

@@ -0,0 +1,237 @@
+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 _ClientEncrypted_instances, _ClientEncrypted_authKey, _ClientEncrypted_authKeyId, _ClientEncrypted_sessionId, _ClientEncrypted_state, _ClientEncrypted_toAcknowledge, _ClientEncrypted_recentAcks, _ClientEncrypted_promises, _ClientEncrypted_L, _ClientEncrypted_LreceiveLoop, _ClientEncrypted_Linvoke, _ClientEncrypted_nextMessageId, _ClientEncrypted_nextSeqNo, _ClientEncrypted_sendMessage, _ClientEncrypted_receiveLoop;
+import { gunzip } from "../0_deps.js";
+import { bigIntFromBuffer, CacheMap, drop, getLogger, getRandomBigInt, sha1, UNREACHABLE } from "../1_utilities.js";
+import { Message_, MessageContainer, name, RPCResult, TLError, TLReader, types } from "../2_tl.js";
+import { upgradeInstance } from "../4_errors.js";
+import { ClientAbstract } from "./0_client_abstract.js";
+import { decryptMessage, encryptMessage, getMessageId } from "./0_message.js";
+import { ConnectionError } from "./0_types.js";
+// global ClientEncrypted ID counter for logs
+let id = 0;
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+export class ClientEncrypted extends ClientAbstract {
+    constructor(params) {
+        super(params);
+        _ClientEncrypted_instances.add(this);
+        _ClientEncrypted_authKey.set(this, new Uint8Array());
+        _ClientEncrypted_authKeyId.set(this, 0n);
+        _ClientEncrypted_sessionId.set(this, getRandomBigInt(8, true, false));
+        _ClientEncrypted_state.set(this, { serverSalt: 0n, seqNo: 0, messageId: 0n });
+        _ClientEncrypted_toAcknowledge.set(this, new Set());
+        _ClientEncrypted_recentAcks.set(this, new CacheMap(20));
+        _ClientEncrypted_promises.set(this, new Map());
+        // loggers
+        _ClientEncrypted_L.set(this, void 0);
+        _ClientEncrypted_LreceiveLoop.set(this, void 0);
+        _ClientEncrypted_Linvoke.set(this, void 0);
+        // receive loop handlers
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const L = __classPrivateFieldSet(this, _ClientEncrypted_L, getLogger("ClientEncrypted").client(id++), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_LreceiveLoop, L.branch("receiveLoop"), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_Linvoke, L.branch("invoke"), "f");
+    }
+    async connect() {
+        await super.connect();
+        drop(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_receiveLoop).call(this)); // TODO: ability to join this promise
+    }
+    async setAuthKey(key) {
+        const hash = await sha1(key);
+        __classPrivateFieldSet(this, _ClientEncrypted_authKeyId, bigIntFromBuffer(hash.slice(-8), true, false), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_authKey, key, "f");
+    }
+    get authKey() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f");
+    }
+    set serverSalt(serverSalt) {
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt = serverSalt;
+    }
+    get serverSalt() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt;
+    }
+    async invoke(function_, noWait) {
+        const messageId = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this);
+        const message__ = new Message_(messageId, __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, true), function_);
+        let message_;
+        let container = undefined;
+        if (__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").size) {
+            const ack = new Message_(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), new types.Msgs_ack({ msg_ids: [...__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f")] }));
+            __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").set(ack.id, { container, message: ack });
+            message_ = new MessageContainer(container = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), [message__, ack]);
+        }
+        else {
+            message_ = message__;
+        }
+        await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, message_);
+        __classPrivateFieldGet(this, _ClientEncrypted_Linvoke, "f").debug("invoked", function_[name]);
+        if (noWait) {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, {
+                container,
+                message: message__,
+                call: function_,
+            });
+            return;
+        }
+        return await new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, { container, message: message__, resolve, reject, call: function_ });
+        }).then((v) => v);
+    }
+}
+_ClientEncrypted_authKey = new WeakMap(), _ClientEncrypted_authKeyId = new WeakMap(), _ClientEncrypted_sessionId = new WeakMap(), _ClientEncrypted_state = new WeakMap(), _ClientEncrypted_toAcknowledge = new WeakMap(), _ClientEncrypted_recentAcks = new WeakMap(), _ClientEncrypted_promises = new WeakMap(), _ClientEncrypted_L = new WeakMap(), _ClientEncrypted_LreceiveLoop = new WeakMap(), _ClientEncrypted_Linvoke = new WeakMap(), _ClientEncrypted_instances = new WeakSet(), _ClientEncrypted_nextMessageId = function _ClientEncrypted_nextMessageId() {
+    return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId = getMessageId(__classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId);
+}, _ClientEncrypted_nextSeqNo = function _ClientEncrypted_nextSeqNo(contentRelated) {
+    let seqNo = __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo * 2;
+    if (contentRelated) {
+        seqNo++;
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo++;
+    }
+    return seqNo;
+}, _ClientEncrypted_sendMessage = async function _ClientEncrypted_sendMessage(message) {
+    const payload = await encryptMessage(message, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt, __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f"));
+    await this.transport.transport.send(payload);
+}, _ClientEncrypted_receiveLoop = async function _ClientEncrypted_receiveLoop() {
+    if (!this.transport) {
+        UNREACHABLE();
+    }
+    while (this.connected) {
+        try {
+            const buffer = await this.transport.transport.receive();
+            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").inBin(buffer);
+            let decrypted;
+            try {
+                decrypted = await (decryptMessage(buffer, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f")));
+                __classPrivateFieldGet(this, _ClientEncrypted_L, "f").in(decrypted);
+            }
+            catch (err) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to decrypt message:", err);
+                this.handlers.error?.(err, "decryption");
+                continue;
+            }
+            const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
+            for (const message of messages) {
+                let body = message.body;
+                if (body instanceof types.Gzip_packed) {
+                    body = new TLReader(gunzip(body.packed_data)).readObject();
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("received", (typeof body === "object" && name in body) ? body[name] : body.constructor.name);
+                if (body instanceof types._Updates || body instanceof types._Update) {
+                    this.handlers.updates?.(body, null);
+                }
+                else if (body instanceof types.New_session_created) {
+                    this.serverSalt = body.server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                }
+                else if (message.body instanceof RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof types.Gzip_packed) {
+                        result = new TLReader(gunzip(result.packed_data)).readObject();
+                    }
+                    if (result instanceof types.Rpc_error) {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", result.error_code, result.error_message);
+                    }
+                    else {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", (typeof result === "object" && name in result) ? result[name] : result.constructor.name);
+                    }
+                    const messageId = message.body.messageId;
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(messageId);
+                    const resolvePromise = () => {
+                        if (promise) {
+                            if (result instanceof types.Rpc_error) {
+                                promise.reject?.(upgradeInstance(result, promise.call));
+                            }
+                            else {
+                                promise.resolve?.(result);
+                            }
+                            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(messageId);
+                        }
+                    };
+                    if (result instanceof types._Updates || result instanceof types._Update) {
+                        this.handlers.updates?.(result, promise?.call ?? null, resolvePromise);
+                    }
+                    else {
+                        this.handlers.result?.(result, resolvePromise);
+                    }
+                }
+                else if (message.body instanceof types.Pong) {
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.msg_id);
+                    if (promise) {
+                        promise.resolve?.(message.body);
+                        __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(message.body.msg_id);
+                    }
+                }
+                else if (message.body instanceof types.Bad_server_salt) {
+                    __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("server salt reassigned");
+                    this.serverSalt = message.body.new_server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.bad_msg_id);
+                    const ack = __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").get(message.body.bad_msg_id);
+                    if (promise) {
+                        drop(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                    }
+                    else if (ack) {
+                        drop(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                    }
+                    else {
+                        for (const promise of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").values()) {
+                            if (promise.container && promise.container == message.body.bad_msg_id) {
+                                drop(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                            }
+                        }
+                        for (const ack of __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").values()) {
+                            if (ack.container && ack.container == message.body.bad_msg_id) {
+                                drop(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                            }
+                        }
+                    }
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").add(message.id);
+            }
+        }
+        catch (err) {
+            if (!this.connected) {
+                break;
+            }
+            else if (err instanceof TLError) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to deserialize:", err);
+                this.handlers.error?.(err, "deserialization");
+            }
+            else {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("unexpected error:", err);
+            }
+        }
+    }
+    if (!this.connected) {
+        for (const [key, { reject }] of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").entries()) {
+            reject?.(new ConnectionError("Connection was closed"));
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(key);
+        }
+    }
+    else {
+        UNREACHABLE();
+    }
+};

package/esm/client/{2_client_plain.d.ts → 1_client_plain.d.ts}

@@ -7,6 +7,9 @@ export interface ClientPlainParams extends ClientAbstractParams {
      */
     publicKeys?: PublicKeys;
 }
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 export declare class ClientPlain extends ClientAbstract {
     #private;
     constructor(params?: ClientPlainParams);

package/esm/client/{2_client_plain.js → 1_client_plain.js}

@@ -18,11 +18,14 @@ import { ClientAbstract } from "./0_client_abstract.js";
 import { getMessageId, packUnencryptedMessage, unpackUnencryptedMessage } from "./0_message.js";
 const L = getLogger("ClientPlain");
 const LcreateAuthKey = L.branch("createAuthKey");
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 export class ClientPlain extends ClientAbstract {
     constructor(params) {
         super(params);
         _ClientPlain_publicKeys.set(this, void 0);
-        _ClientPlain_lastMsgId.set(this, 0n);
+        _ClientPlain_lastMsgId.set(this, 0n); // TODO: refactor
         __classPrivateFieldSet(this, _ClientPlain_publicKeys, params?.publicKeys ?? PUBLIC_KEYS, "f");
     }
     async invoke(function_) {

package/esm/client/1_composer.d.ts

@@ -1,7 +1,7 @@
+import { MaybePromise } from "../1_utilities.js";
 import { Update, UpdateIntersection, User } from "../3_types.js";
 import { FilterQuery, WithFilter } from "./0_filters.js";
-type MaybePromise<T> = T | Promise<T>;
-export type NextFunction = () => Promise<void>;
+export type NextFunction<T = void> = () => Promise<T>;
 export type MiddlewareFn<C> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
 export interface MiddlewareObj<C> {
     middleware: () => MiddlewareFn<C>;
@@ -27,4 +27,3 @@ export declare class Composer<C extends {
         prefixes: string | string[];
     }, ...middleware: Middleware<WithFilter<C, "message:text">>[]): Composer<WithFilter<C, "message:text">>;
 }
-export {};

package/esm/client/2_message_manager.d.ts

@@ -33,7 +33,7 @@ export declare class MessageManager {
     sendVideo(chatId: ID, video: FileSource, params?: SendVideoParams): Promise<import("../3_types.js").MessageVideo>;
     sendDocument(chatId: ID, document: FileSource, params?: SendDocumentParams): Promise<import("../3_types.js").MessageDocument>;
     sendPhoto(chatId: ID, photo: FileSource, params?: SendPhotoParams): Promise<import("../3_types.js").MessagePhoto>;
-    resolveFileId(maybeFileId: string, expectedFileType: FileType): {
+    resolveFileId(maybeFileId: string, expectedFileType: FileType | FileType[]): {
         id: bigint;
         access_hash: bigint;
         file_reference: Uint8Array;

package/esm/client/2_message_manager.js

@@ -389,7 +389,7 @@ export class MessageManager {
         let media = null;
         const spoiler = params?.hasSpoiler ? true : undefined;
         if (typeof photo === "string") {
-            const fileId = this.resolveFileId(photo, FileType.Photo);
+            const fileId = this.resolveFileId(photo, [FileType.Photo, FileType.ProfilePhoto]);
             if (fileId != null) {
                 media = new types.InputMediaPhoto({
                     id: new types.InputPhoto(fileId),
@@ -411,6 +411,7 @@ export class MessageManager {
         return assertMessageType(message, "photo");
     }
     resolveFileId(maybeFileId, expectedFileType) {
+        expectedFileType = Array.isArray(expectedFileType) ? expectedFileType : [expectedFileType];
         let fileId = null;
         try {
             fileId = deserializeFileId(maybeFileId);
@@ -419,7 +420,7 @@ export class MessageManager {
             __classPrivateFieldGet(this, _MessageManager_LresolveFileId, "f").warning(err);
         }
         if (fileId != null) {
-            if (fileId.type != expectedFileType) {
+            if (!expectedFileType.includes(fileId.type)) {
                 UNREACHABLE();
             }
             return {