teleproto 1.223.2 → 1.224.1

package/Utils.js

@@ -920,6 +920,12 @@ function getInputMedia(media, { isPhoto = false, attributes = undefined, forceDo
             correctAnswers: correctAnswers,
             solution: media.results.solution,
             solutionEntities: media.results.solutionEntities,
+            attachedMedia: media.attachedMedia
+                ? getInputMedia(media.attachedMedia)
+                : undefined,
+            solutionMedia: media.results.solutionMedia
+                ? getInputMedia(media.results.solutionMedia)
+                : undefined,
         });
     }
     if (media instanceof tl_1.Api.Poll) {

package/Version.d.ts

@@ -1 +1 @@
-export declare const version = "1.223.2";
+export declare const version = "1.224.1";

package/Version.js

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

package/client/TelegramClient.d.ts

@@ -352,7 +352,7 @@ export declare class TelegramClient extends TelegramBaseClient {
      * );
      * ```
      */
-    downloadFile(inputLocation: Api.TypeInputFileLocation, fileParams?: downloadMethods.DownloadFileParamsV2): Promise<string | Buffer<ArrayBufferLike> | undefined>;
+    downloadFile(inputLocation: Api.TypeInputFileLocation, fileParams?: downloadMethods.DownloadFileParams): Promise<string | Buffer<ArrayBufferLike> | undefined>;
     /**
      * Iterates over a file download, yielding chunks of the file.
      * This method can be used to stream files in a more convenient way, since it offers more control (pausing, resuming, etc.)
@@ -1130,6 +1130,8 @@ export declare class TelegramClient extends TelegramBaseClient {
         port: number;
     }>;
     /** @hidden */
+    _getDownloadConcurrency(fileSize: number): Promise<number>;
+    /** @hidden */
     _removeSender(dcId: number): void;
     /** @hidden */
     _getResponseMessage(req: any, result: any, inputChat: any): Api.TypeMessage | Map<number, Api.Message> | (Api.Message | undefined)[] | undefined;

package/client/TelegramClient.js

@@ -431,7 +431,7 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
      * ```
      */
     downloadFile(inputLocation, fileParams = {}) {
-        return downloadMethods.downloadFileV2(this, inputLocation, fileParams);
+        return downloadMethods.downloadFile(this, inputLocation, fileParams);
     }
     /**
      * Iterates over a file download, yielding chunks of the file.
@@ -1260,6 +1260,45 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
         throw new Error(`Cannot find the DC with the ID of ${dcId}`);
     }
     /** @hidden */
+    async _getDownloadConcurrency(fileSize) {
+        var _a, _b, _c, _d;
+        if (!this._appConfig) {
+            try {
+                const result = await this.invoke(new tl_1.Api.help.GetAppConfig({ hash: 0 }));
+                if (result instanceof tl_1.Api.help.AppConfig) {
+                    this._appConfig = {};
+                    const walk = (v) => {
+                        if (v instanceof tl_1.Api.JsonObject) {
+                            const obj = {};
+                            for (const kv of v.value) {
+                                obj[kv.key] = walk(kv.value);
+                            }
+                            return obj;
+                        }
+                        if (v instanceof tl_1.Api.JsonArray)
+                            return v.value.map(walk);
+                        if (v instanceof tl_1.Api.JsonString)
+                            return v.value;
+                        if (v instanceof tl_1.Api.JsonNumber)
+                            return v.value;
+                        if (v instanceof tl_1.Api.JsonBool)
+                            return v.value;
+                        if (v instanceof tl_1.Api.JsonNull)
+                            return null;
+                        return v;
+                    };
+                    this._appConfig = walk(result.config);
+                }
+            }
+            catch (_e) {
+                this._appConfig = {};
+            }
+        }
+        const smallLimit = (_b = (_a = this._appConfig) === null || _a === void 0 ? void 0 : _a.small_queue_max_active_operations_count) !== null && _b !== void 0 ? _b : 4;
+        const largeLimit = (_d = (_c = this._appConfig) === null || _c === void 0 ? void 0 : _c.large_queue_max_active_operations_count) !== null && _d !== void 0 ? _d : 8;
+        return fileSize > 20 * 1024 * 1024 ? largeLimit : smallLimit;
+    }
+    /** @hidden */
     _removeSender(dcId) {
         delete this._borrowedSenderPromises[dcId];
     }

package/client/downloads.d.ts

@@ -19,30 +19,7 @@ export interface progressCallback {
     /** Does nothing for now. */
     acceptsBuffer?: boolean;
 }
-/**
- * Low level interface for downloading files
- */
 export interface DownloadFileParams {
-    /** The dcId that the file belongs to. Used to borrow a sender from that DC */
-    dcId: number;
-    /** How much to download. The library will download until it reaches this amount.<br/>
-     *  can be useful for downloading by chunks */
-    fileSize?: number;
-    /** Used to determine how many download tasks should be run in parallel. anything above 16 is unstable. */
-    workers?: number;
-    /** How much to download in each chunk. The larger the less requests to be made. (max is 512kb). */
-    partSizeKb?: number;
-    /** Where to start downloading. useful for chunk downloading. */
-    start?: number;
-    /** Where to stop downloading. useful for chunk downloading. */
-    end?: number;
-    /** A callback function accepting two parameters:     ``(received bytes, total)``.     */
-    progressCallback?: progressCallback;
-}
-/**
- * Low level interface for downloading files
- */
-export interface DownloadFileParamsV2 {
     /**
      * The output file path, directory,buffer, or stream-like object.
      * If the path exists and is a file, it will be overwritten.
@@ -60,7 +37,6 @@ export interface DownloadFileParamsV2 {
     partSizeKb?: number;
     /** Progress callback accepting one param. (progress :number) which is a float between 0 and 1 */
     progressCallback?: progressCallback;
-    /** */
     msgData?: [EntityLike, number];
 }
 /**
@@ -112,7 +88,7 @@ export declare class GenericDownloadIter extends DirectDownloadIter {
 /** @hidden */
 export declare function iterDownload(client: TelegramClient, { file, offset, stride, limit, chunkSize, requestSize, fileSize, dcId, msgData, }: IterDownloadFunction): DirectDownloadIter;
 /** @hidden */
-export declare function downloadFileV2(client: TelegramClient, inputLocation: Api.TypeInputFileLocation, { outputFile, partSizeKb, fileSize, progressCallback, dcId, msgData, }: DownloadFileParamsV2): Promise<string | Buffer<ArrayBufferLike> | undefined>;
+export declare function downloadFile(client: TelegramClient, inputLocation: Api.TypeInputFileLocation, { outputFile, partSizeKb, fileSize, progressCallback, dcId, msgData, }: DownloadFileParams): Promise<string | Buffer<ArrayBufferLike> | undefined>;
 /**
  * All of these are optional and will be calculated automatically if not specified.
  */

package/client/downloads.js

@@ -45,7 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericDownloadIter = exports.DirectDownloadIter = void 0;
 exports.iterDownload = iterDownload;
-exports.downloadFileV2 = downloadFileV2;
+exports.downloadFile = downloadFile;
 exports.downloadMedia = downloadMedia;
 exports._downloadDocument = _downloadDocument;
 exports._downloadContact = _downloadContact;
@@ -61,6 +61,7 @@ const requestIter_1 = require("../requestIter");
 const errors_1 = require("../errors");
 const fs_1 = require("fs");
 const extensions_1 = require("../extensions");
+const CTR_1 = require("../crypto/CTR");
 const fs = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const big_integer_1 = __importDefault(require("big-integer"));
@@ -68,12 +69,10 @@ const big_integer_1 = __importDefault(require("big-integer"));
 const sizeTypes = ["w", "y", "d", "x", "c", "m", "b", "a", "s"];
 // Chunk sizes for `upload.getFile` must be multiple of the smallest size
 const MIN_CHUNK_SIZE = 4096;
-const DEFAULT_CHUNK_SIZE = 64; // kb
 const ONE_MB = 1024 * 1024;
-const REQUEST_TIMEOUT = 15000;
-const DISCONNECT_SLEEP = 1000;
 const TIMED_OUT_SLEEP = 1000;
-const MAX_CHUNK_SIZE = 512 * 1024;
+const MAX_CHUNK_SIZE = ONE_MB;
+const MAX_WORKERS = 16;
 class DirectDownloadIter extends requestIter_1.RequestIter {
     constructor() {
         super(...arguments);
@@ -84,6 +83,8 @@ class DirectDownloadIter extends requestIter_1.RequestIter {
             location: fileLocation,
             offset,
             limit: requestSize,
+            precise: true,
+            cdnSupported: false,
         });
         this.total = fileSize;
         this._stride = stride;
@@ -276,21 +277,150 @@ function returnWriterValue(writer) {
         }
     }
 }
+function getDownloadPartSize(fileSize) {
+    if (!fileSize)
+        return 256;
+    if (fileSize.lesser(10 * ONE_MB))
+        return 256;
+    if (fileSize.lesser(100 * ONE_MB))
+        return 512;
+    return 1024;
+}
+function computeCdnIv(initialIv, offset) {
+    const iv = Buffer.from(initialIv);
+    let carry = Math.floor(offset / 16);
+    for (let i = 15; i >= 0 && carry > 0; i--) {
+        carry += iv[i];
+        iv[i] = carry & 0xff;
+        carry >>= 8;
+    }
+    return iv;
+}
+async function verifyFileHashes(data, offset, hashes) {
+    for (const hash of hashes) {
+        const hashOffset = typeof hash.offset === "number"
+            ? hash.offset
+            : hash.offset.toJSNumber();
+        const hashLimit = hash.limit;
+        const localOffset = hashOffset - offset;
+        if (localOffset < 0 || localOffset + hashLimit > data.length)
+            continue;
+        const chunk = data.subarray(localOffset, localOffset + hashLimit);
+        const computed = await (0, Helpers_1.sha256)(chunk);
+        if (!computed.equals(hash.hash)) {
+            return false;
+        }
+    }
+    return true;
+}
+async function downloadChunk(client, location, offset, limit, dcId, senderRef) {
+    var _a, _b, _c, _d;
+    let timedOut = false;
+    while (true) {
+        try {
+            if (!senderRef.sender || !senderRef.sender.isConnected()) {
+                senderRef.sender = await client.getSender((_c = (_b = (_a = senderRef.sender) === null || _a === void 0 ? void 0 : _a.dcId) !== null && _b !== void 0 ? _b : dcId) !== null && _c !== void 0 ? _c : 0);
+            }
+            const result = await client.invokeWithSender(new tl_1.Api.upload.GetFile({
+                location,
+                offset,
+                limit,
+                precise: true,
+                cdnSupported: false,
+            }), senderRef.sender);
+            if (result instanceof tl_1.Api.upload.FileCdnRedirect) {
+                return await downloadFromCdn(client, senderRef, result, location, offset, limit);
+            }
+            return result.bytes;
+        }
+        catch (e) {
+            if (e.errorMessage === "TIMEOUT") {
+                if (timedOut) {
+                    throw e;
+                }
+                timedOut = true;
+                client._log.info("Got timeout while downloading file, retrying once");
+                await (0, Helpers_1.sleep)(TIMED_OUT_SLEEP);
+                continue;
+            }
+            else if (e instanceof errors_1.FileMigrateError) {
+                client._log.info("File lives in another DC");
+                senderRef.sender = await client.getSender(e.newDc);
+                continue;
+            }
+            else if (e.errorMessage === "FLOOD_WAIT" ||
+                ((_d = e.errorMessage) === null || _d === void 0 ? void 0 : _d.startsWith("FLOOD_WAIT_"))) {
+                const seconds = e.seconds || parseInt(e.errorMessage.split("_").pop()) || 1;
+                client._log.warn(`Flood wait ${seconds}s during download`);
+                await (0, Helpers_1.sleep)(seconds * 1000);
+                continue;
+            }
+            throw e;
+        }
+    }
+}
+async function downloadFromCdn(client, originSenderRef, redirect, _location, offset, limit) {
+    var _a, _b, _c, _d;
+    const cdnSender = await client.getSender(redirect.dcId);
+    const offsetNum = typeof offset === "number" ? offset : offset.toJSNumber();
+    while (true) {
+        const cdnResult = await client.invokeWithSender(new tl_1.Api.upload.GetCdnFile({
+            fileToken: redirect.fileToken,
+            offset,
+            limit,
+        }), cdnSender);
+        if (cdnResult instanceof tl_1.Api.upload.CdnFileReuploadNeeded) {
+            const originSender = await client.getSender((_b = (_a = originSenderRef.sender) === null || _a === void 0 ? void 0 : _a.dcId) !== null && _b !== void 0 ? _b : 0);
+            await client.invokeWithSender(new tl_1.Api.upload.ReuploadCdnFile({
+                fileToken: redirect.fileToken,
+                requestToken: cdnResult.requestToken,
+            }), originSender);
+            continue;
+        }
+        const iv = computeCdnIv(redirect.encryptionIv, offsetNum);
+        const ctr = new CTR_1.CTR(redirect.encryptionKey, iv);
+        const decrypted = ctr.encrypt(cdnResult.bytes);
+        let hashes = redirect.fileHashes;
+        if (!hashes || hashes.length === 0) {
+            const cdnHashes = await client.invokeWithSender(new tl_1.Api.upload.GetCdnFileHashes({
+                fileToken: redirect.fileToken,
+                offset,
+            }), await client.getSender((_d = (_c = originSenderRef.sender) === null || _c === void 0 ? void 0 : _c.dcId) !== null && _d !== void 0 ? _d : 0));
+            hashes = cdnHashes;
+        }
+        if (hashes && hashes.length > 0) {
+            const valid = await verifyFileHashes(decrypted, offsetNum, hashes);
+            if (!valid) {
+                throw new Error("CDN file hash verification failed");
+            }
+        }
+        return decrypted;
+    }
+}
 /** @hidden */
-async function downloadFileV2(client, inputLocation, { outputFile = undefined, partSizeKb = undefined, fileSize = undefined, progressCallback = undefined, dcId = undefined, msgData = undefined, }) {
+async function downloadFile(client, inputLocation, { outputFile = undefined, partSizeKb = undefined, fileSize = undefined, progressCallback = undefined, dcId = undefined, msgData = undefined, }) {
     var _a, e_1, _b, _c;
     if (!partSizeKb) {
-        if (!fileSize) {
-            partSizeKb = 64;
-        }
-        else {
-            partSizeKb = utils.getAppropriatedPartSize(fileSize);
-        }
+        partSizeKb = getDownloadPartSize(fileSize || undefined);
     }
     const partSize = Math.floor(partSizeKb * 1024);
-    if (partSize % MIN_CHUNK_SIZE != 0) {
+    if (partSize % MIN_CHUNK_SIZE !== 0) {
         throw new Error("The part size must be evenly divisible by 4096");
     }
+    if (fileSize && fileSize.greater(0)) {
+        const sizeNum = fileSize.toJSNumber();
+        const workers = await client._getDownloadConcurrency(sizeNum);
+        if (workers > 1) {
+            return _downloadParallel(client, inputLocation, {
+                outputFile,
+                partSize,
+                fileSize,
+                workers: Math.min(workers, MAX_WORKERS),
+                dcId,
+                progressCallback,
+            });
+        }
+    }
     const writer = getWriter(outputFile);
     let downloaded = big_integer_1.default.zero;
     try {
@@ -324,36 +454,49 @@ async function downloadFileV2(client, inputLocation, { outputFile = undefined, p
         closeWriter(writer);
     }
 }
-class Foreman {
-    constructor(maxWorkers) {
-        this.maxWorkers = maxWorkers;
-        this.activeWorkers = 0;
-    }
-    requestWorker() {
-        this.activeWorkers++;
-        if (this.activeWorkers > this.maxWorkers) {
-            this.deferred = createDeferred();
-            return this.deferred.promise;
+async function _downloadParallel(client, inputLocation, params) {
+    const { outputFile, partSize, fileSize, workers, dcId, progressCallback } = params;
+    const fileSizeNum = fileSize.toJSNumber();
+    const partCount = Math.ceil(fileSizeNum / partSize);
+    const writer = getWriter(outputFile);
+    let downloaded = big_integer_1.default.zero;
+    const senderRef = {};
+    senderRef.sender = await client.getSender(dcId !== null && dcId !== void 0 ? dcId : 0);
+    client._log.info(`Starting parallel download: ${partCount} parts, ${workers} workers, ${partSize / 1024}KB chunks`);
+    try {
+        for (let i = 0; i < partCount; i += workers) {
+            const batchEnd = Math.min(i + workers, partCount);
+            const batchPromises = [];
+            for (let j = i; j < batchEnd; j++) {
+                const offset = (0, big_integer_1.default)(j).multiply(partSize);
+                batchPromises.push((async (partIndex) => {
+                    const partSenderRef = {
+                        sender: senderRef.sender,
+                    };
+                    const data = await downloadChunk(client, inputLocation, offset, partSize, dcId, partSenderRef);
+                    senderRef.sender = partSenderRef.sender;
+                    return { index: partIndex, data };
+                })(j));
+            }
+            const results = await Promise.all(batchPromises);
+            results.sort((a, b) => a.index - b.index);
+            for (const { data } of results) {
+                await writer.write(data);
+                downloaded = downloaded.add(data.length);
+                if (progressCallback) {
+                    if (progressCallback.isCanceled) {
+                        throw new Error("USER_CANCELED");
+                    }
+                    await progressCallback(downloaded, fileSize);
+                }
+            }
         }
-        return Promise.resolve();
+        return returnWriterValue(writer);
     }
-    releaseWorker() {
-        this.activeWorkers--;
-        if (this.deferred && this.activeWorkers <= this.maxWorkers) {
-            this.deferred.resolve();
-        }
+    finally {
+        closeWriter(writer);
     }
 }
-function createDeferred() {
-    let resolve;
-    const promise = new Promise((_resolve) => {
-        resolve = _resolve;
-    });
-    return {
-        promise,
-        resolve: resolve,
-    };
-}
 /** @hidden */
 async function downloadMedia(client, messageOrMedia, outputFile, thumb, progressCallback) {
     /*
@@ -424,7 +567,7 @@ async function _downloadDocument(client, doc, outputFile, date, thumb, progressC
             return _downloadCachedPhotoSize(size, outputFile);
         }
     }
-    return await downloadFileV2(client, new tl_1.Api.InputDocumentFileLocation({
+    return await downloadFile(client, new tl_1.Api.InputDocumentFileLocation({
         id: doc.id,
         accessHash: doc.accessHash,
         fileReference: doc.fileReference,
@@ -566,7 +709,7 @@ async function _downloadPhoto(client, photo, file, date, thumb, progressCallback
     else {
         fileSize = "size" in size ? size.size : 512;
     }
-    return downloadFileV2(client, new tl_1.Api.InputPhotoFileLocation({
+    return downloadFile(client, new tl_1.Api.InputPhotoFileLocation({
         id: photo.id,
         accessHash: photo.accessHash,
         fileReference: photo.fileReference,

package/client/telegramBaseClient.d.ts

@@ -122,6 +122,10 @@ export declare abstract class TelegramBaseClient {
     /** @hidden */
     _config?: Api.Config;
     /** @hidden */
+    _appConfig?: {
+        [key: string]: any;
+    };
+    /** @hidden */
     _log: Logger;
     /** @hidden */
     _floodSleepThreshold: number;

package/errors/RPCBaseErrors.d.ts

@@ -65,6 +65,15 @@ export declare class FloodError extends RPCError {
     code: number;
     errorMessage: string;
 }
+/**
+ * The account is frozen and cannot use this method.
+ * Clients should call help.getAppConfig to get freeze_since_date,
+ * freeze_until_date, and freeze_appeal_url.
+ */
+export declare class FrozenError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
 /**
  * An internal server error occurred while a request was being processed
  * for example, there was a disruption while accessing a database or file

package/errors/RPCBaseErrors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimedOutError = exports.ServerError = exports.FloodError = exports.AuthKeyError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.InvalidDCError = exports.RPCError = void 0;
+exports.TimedOutError = exports.ServerError = exports.FrozenError = exports.FloodError = exports.AuthKeyError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.InvalidDCError = exports.RPCError = void 0;
 const ts_custom_error_1 = require("ts-custom-error");
 class RPCError extends ts_custom_error_1.CustomError {
     constructor(message, request, code) {
@@ -107,6 +107,19 @@ class FloodError extends RPCError {
     }
 }
 exports.FloodError = FloodError;
+/**
+ * The account is frozen and cannot use this method.
+ * Clients should call help.getAppConfig to get freeze_since_date,
+ * freeze_until_date, and freeze_appeal_url.
+ */
+class FrozenError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 420;
+        this.errorMessage = "FROZEN";
+    }
+}
+exports.FrozenError = FrozenError;
 /**
  * An internal server error occurred while a request was being processed
  * for example, there was a disruption while accessing a database or file

package/errors/RPCErrorList.d.ts

@@ -1,4 +1,4 @@
-import { InvalidDCError, FloodError, BadRequestError } from "./RPCBaseErrors";
+import { InvalidDCError, FloodError, FrozenError, BadRequestError } from "./RPCBaseErrors";
 export declare class UserMigrateError extends InvalidDCError {
     newDc: number;
     constructor(args: any);
@@ -34,4 +34,10 @@ export declare class EmailUnconfirmedError extends BadRequestError {
 export declare class MsgWaitError extends FloodError {
     constructor(args: any);
 }
+export declare class FrozenMethodError extends FrozenError {
+    constructor(args: any);
+}
+export declare class FrozenParticipantError extends BadRequestError {
+    constructor(args: any);
+}
 export declare const rpcErrorRe: Map<RegExp, any>;

package/errors/RPCErrorList.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpcErrorRe = exports.MsgWaitError = exports.EmailUnconfirmedError = exports.NetworkMigrateError = exports.FileMigrateError = exports.FloodTestPhoneWaitError = exports.FloodWaitError = exports.SlowModeWaitError = exports.PhoneMigrateError = exports.UserMigrateError = void 0;
+exports.rpcErrorRe = exports.FrozenParticipantError = exports.FrozenMethodError = exports.MsgWaitError = exports.EmailUnconfirmedError = exports.NetworkMigrateError = exports.FileMigrateError = exports.FloodTestPhoneWaitError = exports.FloodWaitError = exports.SlowModeWaitError = exports.PhoneMigrateError = exports.UserMigrateError = void 0;
 const RPCBaseErrors_1 = require("./RPCBaseErrors");
 class UserMigrateError extends RPCBaseErrors_1.InvalidDCError {
     constructor(args) {
@@ -103,11 +103,27 @@ class MsgWaitError extends RPCBaseErrors_1.FloodError {
     }
 }
 exports.MsgWaitError = MsgWaitError;
+class FrozenMethodError extends RPCBaseErrors_1.FrozenError {
+    constructor(args) {
+        super(`This method cannot be used by a frozen account${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`, args.request, 420);
+        this.message = `This method cannot be used by a frozen account${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`;
+    }
+}
+exports.FrozenMethodError = FrozenMethodError;
+class FrozenParticipantError extends RPCBaseErrors_1.BadRequestError {
+    constructor(args) {
+        super(`This peer cannot be accessed by a frozen account${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`, args.request, 400);
+        this.message = `This peer cannot be accessed by a frozen account${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`;
+    }
+}
+exports.FrozenParticipantError = FrozenParticipantError;
 exports.rpcErrorRe = new Map([
     [/FILE_MIGRATE_(\d+)/, FileMigrateError],
     [/FLOOD_TEST_PHONE_WAIT_(\d+)/, FloodTestPhoneWaitError],
     [/FLOOD_WAIT_(\d+)/, FloodWaitError],
     [/FLOOD_PREMIUM_WAIT_(\d+)/, FloodWaitError],
+    [/FROZEN_METHOD_INVALID/, FrozenMethodError],
+    [/FROZEN_PARTICIPANT_MISSING/, FrozenParticipantError],
     [/MSG_WAIT_(.*)/, MsgWaitError],
     [/PHONE_MIGRATE_(\d+)/, PhoneMigrateError],
     [/SLOWMODE_WAIT_(\d+)/, SlowModeWaitError],

package/network/MTProtoSender.js

@@ -497,6 +497,11 @@ class MTProtoSender {
                         this._handleBadAuthKey(true);
                     }
                 }
+                else if (e instanceof errors_1.TypeNotFoundError) {
+                    // Unknown constructor in an update (e.g. new TL objects not in our schema).
+                    // Safe to skip — no reconnect needed.
+                    this._log.info(`Unknown constructor ${e.invalidConstructorId} in update, skipping (remaining: ${e.remaining.length} bytes)`);
+                }
                 else {
                     this._log.error("Unhandled error while receiving data");
                     if (this._client._errorHandler) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleproto",
-  "version": "1.223.2",
+  "version": "1.224.1",
   "description": "NodeJS MTProto API Telegram client library,",
   "main": "index.js",
   "types": "index.d.ts",