telegram-tghub-better-new 0.1.2 → 0.2.2

package/Utils.d.ts

@@ -1,10 +1,10 @@
 import { Buffer } from "buffer/";
-import type { Entity, EntityLike, MessageIDLike } from "./define";
-import { Api } from "./tl";
 import bigInt from "big-integer";
-import { EntityCache } from "./entityCache";
 import type { ParseInterface } from "./client/messageParse";
 import { CustomFile } from "./client/uploads";
+import type { Entity, EntityLike, MessageIDLike } from "./define";
+import { EntityCache } from "./entityCache";
+import { Api } from "./tl";
 export declare function getFileInfo(fileLocation: Api.Message | Api.MessageMediaDocument | Api.MessageMediaPhoto | Api.TypeInputFileLocation): {
     dcId?: number;
     location: Api.TypeInputFileLocation;

package/Utils.js

@@ -35,11 +35,13 @@ exports.parseUsername = parseUsername;
 exports.rtrim = rtrim;
 exports.getDisplayName = getDisplayName;
 const buffer_1 = require("buffer/");
-const tl_1 = require("./tl");
 const big_integer_1 = __importDefault(require("big-integer"));
 const mime_1 = __importDefault(require("mime"));
+const html_1 = require("./extensions/html");
 const markdown_1 = require("./extensions/markdown");
 const markdownv2_1 = require("./extensions/markdownv2");
+const Helpers_1 = require("./Helpers");
+const tl_1 = require("./tl");
 function getFileInfo(fileLocation) {
     if (!fileLocation || !fileLocation.SUBCLASS_OF_ID) {
         _raiseCastFail(fileLocation, "InputFileLocation");
@@ -96,8 +98,6 @@ function* chunks(arr, size = 100) {
         yield arr.slice(i, i + size);
     }
 }
-const html_1 = require("./extensions/html");
-const Helpers_1 = require("./Helpers");
 const USERNAME_RE = new RegExp("@|(?:https?:\\/\\/)?(?:www\\.)?" +
     "(?:telegram\\.(?:me|dog)|t\\.me)\\/(@|joinchat\\/)?", "i");
 const JPEG_HEADER = buffer_1.Buffer.from("ffd8ffe000104a46494600010100000100010000ffdb004300281c1e231e19282321232d2b28303c64413c37373c7b585d4964918099968f808c8aa0b4e6c3a0aadaad8a8cc8ffcbdaeef5ffffff9bc1fffffffaffe6fdfff8ffdb0043012b2d2d3c353c76414176f8a58ca5f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8ffc00011080000000003012200021101031101ffc4001f0000010501010101010100000000000000000102030405060708090a0bffc400b5100002010303020403050504040000017d01020300041105122131410613516107227114328191a1082342b1c11552d1f02433627282090a161718191a25262728292a3435363738393a434445464748494a535455565758595a636465666768696a737475767778797a838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae1e2e3e4e5e6e7e8e9eaf1f2f3f4f5f6f7f8f9faffc4001f0100030101010101010101010000000000000102030405060708090a0bffc400b51100020102040403040705040400010277000102031104052131061241510761711322328108144291a1b1c109233352f0156272d10a162434e125f11718191a262728292a35363738393a434445464748494a535455565758595a636465666768696a737475767778797a82838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae2e3e4e5e6e7e8e9eaf2f3f4f5f6f7f8f9faffda000c03010002110311003f00", "hex");
@@ -676,7 +676,11 @@ function isVideo(file) {
  */
 function getAttributes(file, { attributes = null, mimeType = undefined, forceDocument = false, voiceNote = false, videoNote = false, supportsStreaming = false, thumb = null, }) {
     var _a, _b, _c, _d;
-    const name = typeof file == "string" ? file : file.name || "unnamed";
+    const name = typeof file == "string"
+        ? file
+        : "name" in file
+            ? file.name || "unnamed"
+            : "unnamed";
     if (mimeType === undefined) {
         mimeType = mime_1.default.getType(name) || "application/octet-stream";
     }

package/Version.d.ts

@@ -1 +1 @@
-export declare const version = "10.0.8";
+export declare const version = "10.1.1";

package/Version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = "10.0.8";
+exports.version = "10.1.1";

package/client/TelegramClient.d.ts

@@ -733,6 +733,25 @@ export declare class TelegramClient extends TelegramBaseClient {
      * @return
      */
     getParticipants(entity: EntityLike, params?: chatMethods.IterParticipantsParams): Promise<import("../Helpers").TotalList<Api.User>>;
+    /**
+     * Kicks a user from a chat.
+     *
+     * Kicking yourself (`'me'`) will result in leaving the chat.
+     *
+     * @note
+     * Attempting to kick someone who was banned will remove their
+     * restrictions (and thus unbanning them), since kicking is just
+     * ban + unban.
+     *
+     * @example
+     * // Kick some user from some chat, and deleting the service message
+     * const msg = await client.kickParticipant(chat, user);
+     * await msg.delete();
+     *
+     * // Leaving chat
+     * await client.kickParticipant(chat, 'me');
+     */
+    kickParticipant(entity: EntityLike, participant: EntityLike): Promise<Api.TypeMessage | Map<number, Api.Message> | (Api.Message | undefined)[] | undefined>;
     /** TODO */
     on(event: any): (f: {
         (event: any): void;
@@ -924,11 +943,11 @@ export declare class TelegramClient extends TelegramBaseClient {
      * @example
      * ```ts
      * const me = await client.getEntity("me");
-     * console.log("My name is",utils.getDisplayName(me));
+     * console.log("My name is", utils.getDisplayName(me));
      *
      * const chat = await client.getInputEntity("username");
-     * for await (const message of client.iterMessages(chat){
-     *     console.log("Message text is",message.text);
+     * for await (const message of client.iterMessages(chat)) {
+     *     console.log("Message text is", message.text);
      * }
      *
      * // Note that you could have used the username directly, but it's

package/client/TelegramClient.js

@@ -806,6 +806,27 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
     getParticipants(entity, params = {}) {
         return chatMethods.getParticipants(this, entity, params);
     }
+    /**
+     * Kicks a user from a chat.
+     *
+     * Kicking yourself (`'me'`) will result in leaving the chat.
+     *
+     * @note
+     * Attempting to kick someone who was banned will remove their
+     * restrictions (and thus unbanning them), since kicking is just
+     * ban + unban.
+     *
+     * @example
+     * // Kick some user from some chat, and deleting the service message
+     * const msg = await client.kickParticipant(chat, user);
+     * await msg.delete();
+     *
+     * // Leaving chat
+     * await client.kickParticipant(chat, 'me');
+     */
+    kickParticipant(entity, participant) {
+        return chatMethods.kickParticipant(this, entity, participant);
+    }
     //endregion
     //region updates
     /** TODO */
@@ -1051,6 +1072,8 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
                 client: this,
                 securityChecks: this._securityChecks,
                 autoReconnectCallback: this._handleReconnect.bind(this),
+                _exportedSenderPromises: this._exportedSenderPromises,
+                reconnectRetries: this._reconnectRetries,
             });
         }
         const connection = new this._connection({

package/client/chats.d.ts

@@ -36,4 +36,6 @@ export interface IterParticipantsParams {
 export declare function iterParticipants(client: TelegramClient, entity: EntityLike, { limit, offset, search, filter, showTotal }: IterParticipantsParams): _ParticipantsIter;
 /** @hidden */
 export declare function getParticipants(client: TelegramClient, entity: EntityLike, params: IterParticipantsParams): Promise<TotalList<Api.User>>;
+/** @hidden */
+export declare function kickParticipant(client: TelegramClient, entity: EntityLike, participant: EntityLike): Promise<Api.TypeMessage | Map<number, Api.Message> | (Api.Message | undefined)[] | undefined>;
 export {};

package/client/chats.js

@@ -6,12 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._ParticipantsIter = void 0;
 exports.iterParticipants = iterParticipants;
 exports.getParticipants = getParticipants;
+exports.kickParticipant = kickParticipant;
 const Helpers_1 = require("../Helpers");
 const requestIter_1 = require("../requestIter");
 const __1 = require("../");
 const tl_1 = require("../tl");
 const big_integer_1 = __importDefault(require("big-integer"));
 const inspect_1 = require("../inspect");
+const Utils_1 = require("../Utils");
 const _MAX_PARTICIPANTS_CHUNK_SIZE = 200;
 const _MAX_ADMIN_LOG_CHUNK_SIZE = 100;
 const _MAX_PROFILE_PHOTO_CHUNK_SIZE = 100;
@@ -302,3 +304,47 @@ async function getParticipants(client, entity, params) {
     const it = client.iterParticipants(entity, params);
     return (await it.collect());
 }
+/** @hidden */
+async function kickParticipant(client, entity, participant) {
+    const peer = await client.getInputEntity(entity);
+    const user = await client.getInputEntity(participant);
+    let resp;
+    let request;
+    const type = __1.helpers._entityType(peer);
+    if (type === __1.helpers._EntityType.CHAT) {
+        request = new tl_1.Api.messages.DeleteChatUser({
+            chatId: (0, Helpers_1.returnBigInt)((0, Utils_1.getPeerId)(entity)),
+            userId: (0, Helpers_1.returnBigInt)((0, Utils_1.getPeerId)(participant)),
+        });
+        resp = await client.invoke(request);
+    }
+    else if (type === __1.helpers._EntityType.CHANNEL) {
+        if (user instanceof tl_1.Api.InputPeerSelf) {
+            request = new tl_1.Api.channels.LeaveChannel({
+                channel: peer,
+            });
+            resp = await client.invoke(request);
+        }
+        else {
+            request = new tl_1.Api.channels.EditBanned({
+                channel: peer,
+                participant: user,
+                bannedRights: new tl_1.Api.ChatBannedRights({
+                    untilDate: 0,
+                    viewMessages: true,
+                }),
+            });
+            resp = await client.invoke(request);
+            await (0, Helpers_1.sleep)(500);
+            await client.invoke(new tl_1.Api.channels.EditBanned({
+                channel: peer,
+                participant: user,
+                bannedRights: new tl_1.Api.ChatBannedRights({ untilDate: 0 }),
+            }));
+        }
+    }
+    else {
+        throw new Error("You must pass either a channel or a chat");
+    }
+    return client._getResponseMessage(request, resp, entity);
+}

package/client/downloads.js

@@ -296,10 +296,10 @@ async function downloadFileV2(client, inputLocation, { outputFile = undefined, p
                 _d = false;
                 const chunk = _c;
                 await writer.write(chunk);
+                downloaded = downloaded.add(chunk.length);
                 if (progressCallback) {
                     await progressCallback(downloaded, (0, big_integer_1.default)(fileSize || big_integer_1.default.zero));
                 }
-                downloaded = downloaded.add(chunk.length);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }

package/client/messageParse.js

@@ -155,13 +155,13 @@ function _getResponseMessage(client, request, result, inputChat) {
         if (schedMessage) {
             return schedMessage;
         }
-        client._log.warn(`No randomId in ${request} to map to. returning undefined for ${result}`);
+        client._log.warn(`No randomId in ${request} to map to. returning undefined for ${result} (Message was empty)`);
         return undefined;
     }
     if (!(0, Helpers_1.isArrayLike)(randomId)) {
         let msg = idToMessage.get(randomToId.get(randomId.toString()));
         if (!msg) {
-            client._log.warn(`Request ${request.className} had missing message mapping ${result.className}`);
+            client._log.warn(`Request ${request.className} had missing message mapping ${result.className} (Message was empty)`);
         }
         return msg;
     }
@@ -181,7 +181,7 @@ function _getResponseMessage(client, request, result, inputChat) {
         final.push(tmp2);
     }
     if (warned) {
-        client._log.warn(`Request ${request.className} had missing message mapping ${result.className}`);
+        client._log.warn(`Request ${request.className} had missing message mapping ${result.className} (Message was empty)`);
     }
     const finalToReturn = [];
     for (const rnd of randomId) {

package/client/messages.js

@@ -791,7 +791,7 @@ async function getCommentData(client, entity, message) {
         peer: entity,
         msgId: __1.utils.getMessageId(message),
     }));
-    const relevantMessage = result.messages[0];
+    const relevantMessage = result.messages.reduce((p, c) => (p && p.id < c.id ? p : c));
     let chat;
     for (const c of result.chats) {
         if (relevantMessage.peerId instanceof tl_1.Api.PeerChannel &&

package/client/telegramBaseClient.d.ts

@@ -37,11 +37,16 @@ export interface TelegramClientParams {
      */
     requestRetries?: number;
     /**
-     * How many times the reconnection should retry, either on the initial connection or when Telegram disconnects us.<br/>
+     * How many times the connection should retry, either on the initial connection or when Telegram disconnects us.<br/>
      * May be set to a negative or undefined value for infinite retries, but this is not recommended, since the program can get stuck in an infinite loop.<br/>
      * defaults to 5
      */
     connectionRetries?: number;
+    /**
+     * How many times to reconnect before giving up. This happens after the initial connection is finished<br/>
+     * defaults to infinity
+     */
+    reconnectRetries?: number;
     /**
      * Experimental proxy to be used for the connection. (only supports MTProxies)
      */
@@ -126,6 +131,8 @@ export declare abstract class TelegramBaseClient {
     /** @hidden */
     _connectionRetries: number;
     /** @hidden */
+    _reconnectRetries: number;
+    /** @hidden */
     _retryDelay: number;
     /** @hidden */
     _timeout: number;
@@ -162,7 +169,7 @@ export declare abstract class TelegramBaseClient {
     /** @hidden */
     _ALBUMS: Map<string, [Timeout, Api.TypeUpdate[]]>;
     /** @hidden */
-    private _exportedSenderPromises;
+    _exportedSenderPromises: Map<number, Promise<MTProtoSender>>;
     /** @hidden */
     private _exportedSenderReleaseTimeouts;
     /** @hidden */

package/client/telegramBaseClient.js

@@ -48,7 +48,6 @@ const clientParamsDefault = {
 };
 class TelegramBaseClient {
     constructor(session, apiId, apiHash, clientParams) {
-        var _a;
         /** The current gramJS version. */
         this.__version__ = __1.version;
         /** @hidden */
@@ -82,6 +81,7 @@ class TelegramBaseClient {
         this._requestRetries = clientParams.requestRetries;
         this._downloadRetries = clientParams.downloadRetries;
         this._connectionRetries = clientParams.connectionRetries;
+        this._reconnectRetries = clientParams.reconnectRetries;
         this._retryDelay = clientParams.retryDelay || 0;
         this._timeout = clientParams.timeout;
         this._autoReconnect = clientParams.autoReconnect;
@@ -94,7 +94,7 @@ class TelegramBaseClient {
         }
         this._connection = clientParams.connection;
         let initProxy;
-        if ((_a = this._proxy) === null || _a === void 0 ? void 0 : _a.MTProxy) {
+        if (this._proxy && "MTProxy" in this._proxy) {
             this._connection = TCPMTProxy_1.ConnectionTCPMTProxyAbridged;
             initProxy = new tl_1.Api.InputClientProxy({
                 address: this._proxy.ip,
@@ -118,9 +118,6 @@ class TelegramBaseClient {
         this._selfInputPeer = undefined;
         this.useWSS = clientParams.useWSS;
         this._securityChecks = !!clientParams.securityChecks;
-        if (this.useWSS && this._proxy) {
-            throw new Error("Cannot use SSL with proxies. You need to disable the useWSS client param in TelegramClient");
-        }
         this._entityCache = new entityCache_1.EntityCache();
         // These will be set later
         this._config = undefined;
@@ -295,7 +292,14 @@ class TelegramBaseClient {
         }
         this._exportedSenderReleaseTimeouts.set(dcId, setTimeout(() => {
             this._exportedSenderReleaseTimeouts.delete(dcId);
-            sender.disconnect();
+            if (sender._pendingState.values().length) {
+                console.log("sender already has some hanging states. reconnecting");
+                sender._reconnect();
+                this._borrowExportedSender(dcId, false, sender);
+            }
+            else {
+                sender.disconnect();
+            }
         }, EXPORTED_SENDER_RELEASE_TIMEOUT));
         return sender;
     }
@@ -313,6 +317,8 @@ class TelegramBaseClient {
             onConnectionBreak: this._cleanupExportedSender.bind(this),
             client: this,
             securityChecks: this._securityChecks,
+            _exportedSenderPromises: this._exportedSenderPromises,
+            reconnectRetries: this._reconnectRetries,
         });
     }
     /** @hidden */

package/client/uploads.js

@@ -59,6 +59,7 @@ const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024;
 const UPLOAD_TIMEOUT = 15 * 1000;
 const DISCONNECT_SLEEP = 1000;
 const BUFFER_SIZE_2GB = 2 ** 31;
+const BUFFER_SIZE_20MB = 20 * 1024 * 1024;
 async function getFileBuffer(file, fileSize, maxBufferSize) {
     const options = {};
     if (fileSize > maxBufferSize && file instanceof CustomFile) {
@@ -78,7 +79,7 @@ async function uploadFile(client, fileParams) {
     const isLarge = size > LARGE_FILE_THRESHOLD;
     const partSize = (0, Utils_1.getAppropriatedPartSize)((0, big_integer_1.default)(size)) * KB_TO_BYTES;
     const partCount = Math.floor((size + partSize - 1) / partSize);
-    const buffer = await getFileBuffer(file, size, fileParams.maxBufferSize || BUFFER_SIZE_2GB - 1);
+    const buffer = await getFileBuffer(file, size, fileParams.maxBufferSize || BUFFER_SIZE_20MB - 1);
     // Make sure a new sender can be created before starting upload
     await client.getSender(client.session.dcId);
     if (!workers || !size) {
@@ -98,7 +99,14 @@ async function uploadFile(client, fileParams) {
             end = partCount;
         }
         for (let j = i; j < end; j++) {
-            const bytes = await buffer.slice(j * partSize, (j + 1) * partSize);
+            let endPart = (j + 1) * partSize;
+            if (endPart > size) {
+                endPart = size;
+            }
+            if (endPart == j * partSize) {
+                break;
+            }
+            const bytes = await buffer.slice(j * partSize, endPart);
             // eslint-disable-next-line no-loop-func
             sendingParts.push((async (jMemo, bytesMemo) => {
                 while (true) {

package/client/users.js

@@ -39,6 +39,9 @@ async function invoke(client, request, dcId, otherSender) {
     if (sender == undefined) {
         throw new Error("Cannot send requests while disconnected. You need to call .connect()");
     }
+    if (sender.userDisconnected) {
+        throw new Error("Cannot send requests while disconnected. Please reconnect.");
+    }
     await client._connectedDeferred.promise;
     await request.resolve(client, __1.utils);
     client._lastRequest = new Date().getTime();

package/extensions/MessagePacker.d.ts

@@ -3,7 +3,7 @@ import type { MTProtoState } from "../network/MTProtoState";
 import type { RequestState } from "../network/RequestState";
 export declare class MessagePacker {
     private _state;
-    private _pendingStates;
+    _pendingStates: RequestState[];
     private _queue;
     private _ready;
     private setReady;

package/extensions/MessagePacker.js

@@ -62,7 +62,7 @@ class MessagePacker {
             this._pendingStates.push(state);
             state
                 .promise // Using finally causes triggering `unhandledrejection` event
-                .catch(() => { })
+                .catch((err) => { })
                 .finally(() => {
                 this._pendingStates = this._pendingStates.filter((s) => s !== state);
             });

package/extensions/html.js

@@ -40,6 +40,9 @@ class HTMLToTelegramParser {
         }
         else if (name == "blockquote") {
             EntityType = tl_1.Api.MessageEntityBlockquote;
+            if (attributes.expandable !== undefined) {
+                args.collapsed = true;
+            }
         }
         else if (name == "code") {
             const pre = this._buildingEntities.get("pre");

package/extensions/markdown.js

@@ -39,7 +39,7 @@ class MarkdownParser {
                     foundIndex - tempEntities[foundDelim].offset;
                 entities.push(tempEntities[foundDelim]);
             }
-            message = message.replace(foundDelim, "");
+            message = message.toString().replace(foundDelim, "");
             i = foundIndex;
         }
         return [message, entities];

package/extensions/markdownv2.js

@@ -13,7 +13,7 @@ class MarkdownV2Parser {
         // italic
         message = message.replace(/-(.*?)-/g, "<i>$1</i>");
         // pre
-        message = message.replace(/```(.*?)```/g, "<pre>$1</pre>");
+        message = message.replace(/```([\s\S]*?)```/g, "<pre>$1</pre>");
         // code
         message = message.replace(/`(.*?)`/g, "<code>$1</code>");
         // Spoiler
@@ -22,6 +22,7 @@ class MarkdownV2Parser {
         message = message.replace(/(?<!\!)\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
         // Emoji
         message = message.replace(/!\[([^\]]+)\]\(tg:\/\/emoji\?id=(\d+)\)/g, '<tg-emoji emoji-id="$2">$1</tg-emoji>');
+        //
         return html_1.HTMLParser.parse(message);
     }
     static unparse(text, entities) {

package/network/MTProtoSender.d.ts

@@ -19,9 +19,11 @@ import { RequestState } from "./RequestState";
 import { Connection, UpdateConnectionState } from "./";
 import type { TelegramClient } from "..";
 import { CancellablePromise } from "real-cancellable-promise";
+import { PendingState } from "../extensions/PendingState";
 interface DEFAULT_OPTIONS {
     logger: any;
     retries: number;
+    reconnectRetries: number;
     delay: number;
     autoReconnect: boolean;
     connectTimeout: any;
@@ -34,10 +36,12 @@ interface DEFAULT_OPTIONS {
     client: TelegramClient;
     onConnectionBreak?: CallableFunction;
     securityChecks: boolean;
+    _exportedSenderPromises: Map<number, Promise<MTProtoSender>>;
 }
 export declare class MTProtoSender {
     static DEFAULT_OPTIONS: {
         logger: null;
+        reconnectRetries: number;
         retries: number;
         delay: number;
         autoReconnect: boolean;
@@ -54,6 +58,8 @@ export declare class MTProtoSender {
     private readonly _log;
     private _dcId;
     private readonly _retries;
+    private _reconnectRetries;
+    private _currentRetries;
     private readonly _delay;
     private _connectTimeout;
     private _autoReconnect;
@@ -71,7 +77,7 @@ export declare class MTProtoSender {
     readonly authKey: AuthKey;
     private readonly _state;
     private _sendQueue;
-    private _pendingState;
+    _pendingState: PendingState;
     private readonly _pendingAck;
     private readonly _lastAcks;
     private readonly _handlers;
@@ -85,6 +91,7 @@ export declare class MTProtoSender {
     private _cancelSend;
     cancellableRecvLoopPromise?: CancellablePromise<any>;
     private _finishedConnecting;
+    private _exportedSenderPromises;
     /**
      * @param authKey
      * @param opts

package/network/MTProtoSender.js

@@ -40,6 +40,7 @@ class MTProtoSender {
      * @param opts
      */
     constructor(authKey, opts) {
+        this._exportedSenderPromises = new Map();
         const args = Object.assign(Object.assign({}, MTProtoSender.DEFAULT_OPTIONS), opts);
         this._finishedConnecting = false;
         this._cancelSend = false;
@@ -47,6 +48,8 @@ class MTProtoSender {
         this._log = args.logger;
         this._dcId = args.dcId;
         this._retries = args.retries;
+        this._currentRetries = 0;
+        this._reconnectRetries = args.reconnectRetries;
         this._delay = args.delay;
         this._autoReconnect = args.autoReconnect;
         this._connectTimeout = args.connectTimeout;
@@ -59,6 +62,7 @@ class MTProtoSender {
         this._onConnectionBreak = args.onConnectionBreak;
         this._securityChecks = args.securityChecks;
         this._connectMutex = new async_mutex_1.Mutex();
+        this._exportedSenderPromises = args._exportedSenderPromises;
         /**
          * whether we disconnected ourself or telegram did it.
          */
@@ -328,17 +332,6 @@ class MTProtoSender {
             this._log.debug(`Encrypting ${batch.length} message(s) in ${data.length} bytes for sending`);
             this._log.debug(`Sending   ${batch.map((m) => m.request.className)}`);
             data = await this._state.encryptMessageData(data);
-            try {
-                await this._connection.send(data);
-            }
-            catch (e) {
-                this._log.debug(`Connection closed while sending data ${e}`);
-                if (this._log.canSend(Logger_1.LogLevel.DEBUG)) {
-                    console.error(e);
-                }
-                this._sendLoopHandle = undefined;
-                return;
-            }
             for (const state of batch) {
                 if (!Array.isArray(state)) {
                     if (state.request.classType === "request") {
@@ -353,6 +346,21 @@ class MTProtoSender {
                     }
                 }
             }
+            try {
+                await this._connection.send(data);
+            }
+            catch (e) {
+                /** when the server disconnects us we want to reconnect */
+                if (!this.userDisconnected) {
+                    this._log.debug(`Connection closed while sending data ${e}`);
+                    if (this._log.canSend(Logger_1.LogLevel.DEBUG)) {
+                        console.error(e);
+                    }
+                    this.reconnect();
+                }
+                this._sendLoopHandle = undefined;
+                return;
+            }
             this._log.debug("Encrypted messages put in a queue to be sent");
         }
         this._sendLoopHandle = undefined;
@@ -366,6 +374,13 @@ class MTProtoSender {
                 body = await this._connection.recv();
             }
             catch (e) {
+                if (this._currentRetries > this._reconnectRetries) {
+                    for (const state of this._pendingState.values()) {
+                        state.reject("Maximum reconnection retries reached. Aborting!");
+                    }
+                    this.userDisconnected = true;
+                    return;
+                }
                 /** when the server disconnects us we want to reconnect */
                 if (!this.userDisconnected) {
                     this._log.warn("Connection closed while receiving data");
@@ -443,6 +458,7 @@ class MTProtoSender {
                     }
                 }
             }
+            this._currentRetries = 0;
         }
         this._recvLoopHandle = undefined;
     }
@@ -518,7 +534,6 @@ class MTProtoSender {
      * @private
      */
     _handleRPCResult(message) {
-        var _a;
         const result = message.obj;
         const state = this._pendingState.getAndDelete(result.reqMsgId);
         this._log.debug(`Handling RPC result for message ${result.reqMsgId}`);
@@ -553,7 +568,7 @@ class MTProtoSender {
             try {
                 const reader = new extensions_1.BinaryReader(result.body);
                 const read = state.request.readResult(reader);
-                this._log.debug(`Handling RPC result ${(_a = read === null || read === void 0 ? void 0 : read.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
+                this._log.debug(`Handling RPC result ${read === null || read === void 0 ? void 0 : read.className}`);
                 state.resolve(read);
             }
             catch (err) {
@@ -756,6 +771,21 @@ class MTProtoSender {
     reconnect() {
         if (this._userConnected && !this.isReconnecting) {
             this.isReconnecting = true;
+            this._currentRetries++;
+            if (this._isMainSender) {
+                this._log.debug("Reconnecting all senders");
+                for (const promise of this._exportedSenderPromises.values()) {
+                    promise
+                        .then((sender) => {
+                        if (sender && !sender._isMainSender) {
+                            sender.reconnect();
+                        }
+                    })
+                        .catch((error) => {
+                        this._log.warn("Error getting sender to reconnect to");
+                    });
+                }
+            }
             // we want to wait a second between each reconnect try to not flood the server with reconnects
             // in case of internal server issues.
             (0, Helpers_1.sleep)(1000).then(() => {
@@ -765,7 +795,6 @@ class MTProtoSender {
         }
     }
     async _reconnect() {
-        this._log.debug("Closing current connection...");
         try {
             this._log.warn("[Reconnect] Closing current connection...");
             await this._disconnect();
@@ -779,6 +808,12 @@ class MTProtoSender {
                 console.error(err);
             }
         }
+        this._log.debug(`Adding ${this._sendQueue._pendingStates.length} old request to resend`);
+        for (let i = 0; i < this._sendQueue._pendingStates.length; i++) {
+            if (this._sendQueue._pendingStates[i].msgId != undefined) {
+                this._pendingState.set(this._sendQueue._pendingStates[i].msgId, this._sendQueue._pendingStates[i]);
+            }
+        }
         this._sendQueue.clear();
         this._state.reset();
         const connection = this._connection;
@@ -805,6 +840,7 @@ class MTProtoSender {
 exports.MTProtoSender = MTProtoSender;
 MTProtoSender.DEFAULT_OPTIONS = {
     logger: null,
+    reconnectRetries: Infinity,
     retries: Infinity,
     delay: 2000,
     autoReconnect: true,