@mtkruto/node 0.1.162 → 0.1.183

package/script/5_client.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client/0_params.js"), exports);
-__exportStar(require("./client/2_client_plain.js"), exports);
+__exportStar(require("./client/1_client_plain.js"), exports);
+__exportStar(require("./client/1_client_encrypted.js"), exports);
 __exportStar(require("./client/4_client.js"), exports);
-__exportStar(require("./client/5_composer.js"), exports);

package/script/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/script/client/0_client_abstract.js

@@ -1,15 +1,15 @@
 "use strict";
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientAbstract = void 0;
@@ -53,6 +53,9 @@ class ClientAbstract {
         this.transportProvider = params?.transportProvider ?? (0, _3_transport_js_1.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");
@@ -87,6 +90,9 @@ class ClientAbstract {
         await this.transport.transport.deinitialize();
         await this.transport.connection.close();
     }
+    get disconnected() {
+        return !this.transport?.transport.initialized;
+    }
 }
 exports.ClientAbstract = ClientAbstract;
 _ClientAbstract_dc = new WeakMap();

package/script/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/script/client/0_message.js

@@ -35,14 +35,10 @@ function unpackUnencryptedMessage(buffer) {
 }
 exports.unpackUnencryptedMessage = unpackUnencryptedMessage;
 async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
-    const encoded = message.body[_2_tl_js_1.serialize]();
     const payloadWriter = new _2_tl_js_1.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[_2_tl_js_1.serialize]());
     payloadWriter.write(new Uint8Array((0, _1_utilities_js_1.mod)(-(payloadWriter.buffer.length + 12), 16) + 12));
     const payload = payloadWriter.buffer;
     const messageKey = (await (0, _1_utilities_js_1.sha256)((0, _1_utilities_js_1.concat)(authKey.subarray(88, 120), payload))).subarray(8, 24);
@@ -77,7 +73,8 @@ async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
     plainReader = new _2_tl_js_1.TLReader(plainReader.read(length));
     const cid = plainReader.readInt32(false);
     if (cid == _2_tl_js_1.MessageContainer[_2_tl_js_1.id]) {
-        return _2_tl_js_1.MessageContainer.deserialize(plainReader.buffer);
+        const messages = _2_tl_js_1.MessageContainer.deserialize(plainReader.buffer);
+        return new _2_tl_js_1.MessageContainer(mid, seqno, messages);
     }
     else if (cid == _2_tl_js_1.RPCResult[_2_tl_js_1.id]) {
         const body = _2_tl_js_1.RPCResult.deserialize(plainReader.buffer);

package/script/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/script/client/1_client_encrypted.js

@@ -0,0 +1,241 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEncrypted = void 0;
+const _0_deps_js_1 = require("../0_deps.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const _2_tl_js_1 = require("../2_tl.js");
+const _4_errors_js_1 = require("../4_errors.js");
+const _0_client_abstract_js_1 = require("./0_client_abstract.js");
+const _0_message_js_1 = require("./0_message.js");
+const _0_types_js_1 = require("./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.
+ */
+class ClientEncrypted extends _0_client_abstract_js_1.ClientAbstract {
+    constructor(params) {
+        super(params);
+        _ClientEncrypted_instances.add(this);
+        _ClientEncrypted_authKey.set(this, new Uint8Array());
+        _ClientEncrypted_authKeyId.set(this, 0n);
+        _ClientEncrypted_sessionId.set(this, (0, _1_utilities_js_1.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 _1_utilities_js_1.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, (0, _1_utilities_js_1.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();
+        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_receiveLoop).call(this)); // TODO: ability to join this promise
+    }
+    async setAuthKey(key) {
+        const hash = await (0, _1_utilities_js_1.sha1)(key);
+        __classPrivateFieldSet(this, _ClientEncrypted_authKeyId, (0, _1_utilities_js_1.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 _2_tl_js_1.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 _2_tl_js_1.Message_(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), new _2_tl_js_1.types.Msgs_ack({ msg_ids: [...__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f")] }));
+            __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").set(ack.id, { container, message: ack });
+            message_ = new _2_tl_js_1.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_[_2_tl_js_1.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);
+    }
+}
+exports.ClientEncrypted = ClientEncrypted;
+_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 = (0, _0_message_js_1.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 (0, _0_message_js_1.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) {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+    while (this.connected) {
+        try {
+            const buffer = await this.transport.transport.receive();
+            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").inBin(buffer);
+            let decrypted;
+            try {
+                decrypted = await ((0, _0_message_js_1.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 _2_tl_js_1.MessageContainer ? decrypted.messages : [decrypted];
+            for (const message of messages) {
+                let body = message.body;
+                if (body instanceof _2_tl_js_1.types.Gzip_packed) {
+                    body = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(body.packed_data)).readObject();
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("received", (typeof body === "object" && _2_tl_js_1.name in body) ? body[_2_tl_js_1.name] : body.constructor.name);
+                if (body instanceof _2_tl_js_1.types._Updates || body instanceof _2_tl_js_1.types._Update) {
+                    this.handlers.updates?.(body, null);
+                }
+                else if (body instanceof _2_tl_js_1.types.New_session_created) {
+                    this.serverSalt = body.server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                }
+                else if (message.body instanceof _2_tl_js_1.RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof _2_tl_js_1.types.Gzip_packed) {
+                        result = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(result.packed_data)).readObject();
+                    }
+                    if (result instanceof _2_tl_js_1.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" && _2_tl_js_1.name in result) ? result[_2_tl_js_1.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 _2_tl_js_1.types.Rpc_error) {
+                                promise.reject?.((0, _4_errors_js_1.upgradeInstance)(result, promise.call));
+                            }
+                            else {
+                                promise.resolve?.(result);
+                            }
+                            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(messageId);
+                        }
+                    };
+                    if (result instanceof _2_tl_js_1.types._Updates || result instanceof _2_tl_js_1.types._Update) {
+                        this.handlers.updates?.(result, promise?.call ?? null, resolvePromise);
+                    }
+                    else {
+                        this.handlers.result?.(result, resolvePromise);
+                    }
+                }
+                else if (message.body instanceof _2_tl_js_1.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 _2_tl_js_1.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) {
+                        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                    }
+                    else if (ack) {
+                        (0, _1_utilities_js_1.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) {
+                                (0, _1_utilities_js_1.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) {
+                                (0, _1_utilities_js_1.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 _2_tl_js_1.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 _0_types_js_1.ConnectionError("Connection was closed"));
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(key);
+        }
+    }
+    else {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+};

package/script/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/script/client/{2_client_plain.js → 1_client_plain.js}

@@ -21,11 +21,14 @@ const _0_client_abstract_js_1 = require("./0_client_abstract.js");
 const _0_message_js_1 = require("./0_message.js");
 const L = (0, _1_utilities_js_1.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.
+ */
 class ClientPlain extends _0_client_abstract_js_1.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 ?? _4_constants_js_1.PUBLIC_KEYS, "f");
     }
     async invoke(function_) {

package/script/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/script/client/1_file_manager.d.ts

@@ -1,4 +1,5 @@
-import { Document } from "../3_types.js";
+import { types } from "../2_tl.js";
+import { Sticker } from "../3_types.js";
 import { DownloadParams, UploadParams } from "./0_params.js";
 import { C } from "./0_types.js";
 export declare class FileManager {
@@ -6,5 +7,6 @@ export declare class FileManager {
     constructor(c: C);
     upload(contents: Uint8Array, params?: UploadParams): Promise<import("../tl/2_types.js").InputFile_ | import("../tl/2_types.js").InputFileBig_>;
     download(fileId: string, params?: DownloadParams): AsyncGenerator<Uint8Array, void, unknown>;
-    getCustomEmojiDocuments(id: string | string[]): Promise<Document[]>;
+    getStickerSetName(inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
+    getCustomEmojiStickers(id: string | string[]): Promise<Sticker[]>;
 }

package/script/client/1_file_manager.js

@@ -13,10 +13,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _FileManager_instances, _FileManager_c, _FileManager_Lupload, _FileManager_downloadInner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileManager = void 0;
-const _0_deps_js_1 = require("../0_deps.js");
 const _1_utilities_js_1 = require("../1_utilities.js");
 const _2_tl_js_1 = require("../2_tl.js");
 const _3_types_js_1 = require("../3_types.js");
+const _4_constants_js_1 = require("../4_constants.js");
 const _4_errors_js_1 = require("../4_errors.js");
 const _0_types_js_1 = require("./0_types.js");
 class FileManager {
@@ -129,6 +129,18 @@ class FileManager {
                     }
                     break;
                 }
+                case _3_types_js_1.FileType.Thumbnail: {
+                    const location = new _2_tl_js_1.types.InputDocumentFileLocation({
+                        id: fileId_.location.id,
+                        access_hash: fileId_.location.accessHash,
+                        file_reference: fileId_.fileReference ?? new Uint8Array(),
+                        thumb_size: "thumbnailType" in fileId_.location.source ? String.fromCharCode(fileId_.location.source.thumbnailType) : (0, _1_utilities_js_1.UNREACHABLE)(),
+                    });
+                    for await (const chunk of __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_downloadInner).call(this, location, fileId_.dcId, params)) {
+                        yield chunk;
+                    }
+                    break;
+                }
             }
         }
         else if (fileId_.location.type == "common") {
@@ -146,14 +158,26 @@ class FileManager {
             (0, _1_utilities_js_1.UNREACHABLE)();
         }
     }
-    async getCustomEmojiDocuments(id) {
+    async getStickerSetName(inputStickerSet, hash = 0) {
+        const maybeStickerSetName = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
+        if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < _4_constants_js_1.STICKER_SET_NAME_TTL) {
+            return maybeStickerSetName[0];
+        }
+        else {
+            const stickerSet = await __classPrivateFieldGet(this, _FileManager_c, "f").api.messages.getStickerSet({ stickerset: inputStickerSet, hash });
+            const name = stickerSet[_2_tl_js_1.as](_2_tl_js_1.types.messages.StickerSet).set.short_name;
+            await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
+            return name;
+        }
+    }
+    async getCustomEmojiStickers(id) {
         id = Array.isArray(id) ? id : [id];
         if (!id.length) {
             throw new Error("No custom emoji ID provided");
         }
-        const documents = new Array();
+        const stickers = new Array();
         let shouldFetch = false;
-        for (const [i, id_] of id.entries()) {
+        for (const id_ of id) {
             const maybeDocument = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getCustomEmojiDocument(BigInt(id_));
             if (maybeDocument != null && Date.now() - maybeDocument[1].getTime() <= 30 * 60 * 1000) {
                 const document_ = maybeDocument[0];
@@ -165,8 +189,8 @@ class FileManager {
                 };
                 const fileUniqueId = (0, _3_types_js_1.toUniqueFileId)(fileId_);
                 const fileId = (0, _3_types_js_1.serializeFileId)(fileId_);
-                const document = (0, _3_types_js_1.constructDocument)(document_, new _2_tl_js_1.types.DocumentAttributeFilename({ file_name: `${id[i] ?? "customEmoji"}.${(0, _0_deps_js_1.extension)(document_.mime_type)}` }), fileId, fileUniqueId);
-                documents.push(document);
+                const sticker = await (0, _3_types_js_1.constructSticker)(document_, fileId, fileUniqueId, this.getStickerSetName.bind(this), id_);
+                stickers.push(sticker);
             }
             else {
                 shouldFetch = true;
@@ -174,7 +198,7 @@ class FileManager {
             }
         }
         if (!shouldFetch) {
-            return documents;
+            return stickers;
         }
         const documents_ = await __classPrivateFieldGet(this, _FileManager_c, "f").api.messages.getCustomEmojiDocuments({ document_id: id.map(BigInt) }).then((v) => v.map((v) => v[_2_tl_js_1.as](_2_tl_js_1.types.Document)));
         for (const [i, document_] of documents_.entries()) {
@@ -187,10 +211,10 @@ class FileManager {
             };
             const fileUniqueId = (0, _3_types_js_1.toUniqueFileId)(fileId_);
             const fileId = (0, _3_types_js_1.serializeFileId)(fileId_);
-            const document = (0, _3_types_js_1.constructDocument)(document_, new _2_tl_js_1.types.DocumentAttributeFilename({ file_name: `${id[i] ?? "customEmoji"}.${(0, _0_deps_js_1.extension)(document_.mime_type)}` }), fileId, fileUniqueId);
-            documents.push(document);
+            const sticker = await (0, _3_types_js_1.constructSticker)(document_, fileId, fileUniqueId, this.getStickerSetName.bind(this), id[i]);
+            stickers.push(sticker);
         }
-        return documents;
+        return stickers;
     }
 }
 exports.FileManager = FileManager;

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

@@ -17,7 +17,6 @@ export declare class MessageManager {
         parseMode?: ParseMode;
         entities?: MessageEntity[];
     }): Promise<readonly [string, enums.MessageEntity[] | undefined]>;
-    getStickerSetName(inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
     constructMessage(message_: enums.Message, r?: boolean): Promise<Message>;
     forwardMessages(from: ID, to: ID, messageIds: number[], params?: ForwardMessagesParams): Promise<Message[]>;
     getHistory(chatId: ID, params?: GetHistoryParams): Promise<Message[]>;
@@ -34,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;
@@ -74,5 +73,8 @@ export declare class MessageManager {
     leaveChat(chatId: ID): Promise<void>;
     blockUser(userId: ID): Promise<void>;
     unblockUser(userId: ID): Promise<void>;
+    getChatMember(chatId: ID, userId: ID): Promise<ChatMember>;
+    setChatStickerSet(chatId: ID, setName: string): Promise<void>;
+    deleteChatStickerSet(chatId: ID): Promise<void>;
 }
 export {};