teleproto 1.221.2 → 1.221.4

package/Version.d.ts

@@ -1 +1 @@
-export declare const version = "1.221.2";
+export declare const version = "1.221.4";

package/Version.js

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

package/client/TelegramClient.d.ts

@@ -161,10 +161,62 @@ export declare class TelegramClient extends TelegramBaseClient {
      * @param reCaptchaCallback - callback to handle reCAPTCHA verification
      * @return the phone code hash and whether it was sent via app
      */
-    sendCode(apiCredentials: authMethods.ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<{
-        phoneCodeHash: string;
-        isCodeViaApp: boolean;
-    }>;
+    sendCode(apiCredentials: authMethods.ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<authMethods.SendCodeResult>;
+    /**
+     * Sends an email verification code for login setup.
+     * This is used when Telegram requires email verification during login.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param email - The email address to verify
+     * @returns The email pattern and code length
+     * @example
+     * ```ts
+     * const result = await client.sendVerifyEmailCode(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     "user@example.com"
+     * );
+     * console.log(`Code sent to ${result.emailPattern}, length: ${result.length}`);
+     * ```
+     */
+    sendVerifyEmailCode(phoneNumber: string, phoneCodeHash: string, email: string): Promise<authMethods.SentEmailCodeResult>;
+    /**
+     * Verifies an email address during login setup.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param verification - The verification result (code, Google token, or Apple token)
+     * @returns The verified email and the new sent code for phone verification
+     * @example
+     * ```ts
+     * // Verify with email code
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "code", code: "12345" }
+     * );
+     *
+     * // Or verify with Google Sign-In
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "google", token: "google-id-token" }
+     * );
+     * ```
+     */
+    verifyEmail(phoneNumber: string, phoneCodeHash: string, verification: authMethods.EmailVerificationResult): Promise<authMethods.EmailVerifiedLoginResult>;
+    /**
+     * Resets the login email when the user cannot access their current email.
+     * This will cancel the current email verification and allow setting up a new one.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @returns The new sent code result
+     * @example
+     * ```ts
+     * // User can't access their email, reset it
+     * const newSentCode = await client.resetLoginEmail("+1234567890", "abc123hash");
+     * ```
+     */
+    resetLoginEmail(phoneNumber: string, phoneCodeHash: string): Promise<Api.auth.TypeSentCode>;
     /**
      * Uses the 2FA password to sign in the account.<br/>
      * This function should be used after the user has signed in with the code they received.
@@ -810,6 +862,16 @@ export declare class TelegramClient extends TelegramBaseClient {
      * @return pair of [eventBuilder,CallableFunction]
      */
     listEventHandlers(): [EventBuilder, CallableFunction][];
+    /**
+     * Fetches and processes any updates that were missed while disconnected.
+     * Call this after reconnecting to ensure no updates are lost.
+     * @example
+     * ```ts
+     * await client.connect();
+     * await client.catchUp(); // Fetch missed updates
+     * ```
+     */
+    catchUp(): Promise<void>;
     /**
      * Uploads a file to Telegram's servers, without sending it.
      * @remarks generally it's better to use {@link sendFile} instead.

package/client/TelegramClient.js

@@ -211,6 +211,67 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
     sendCode(apiCredentials, phoneNumber, forceSMS = false, reCaptchaCallback) {
         return authMethods.sendCode(this, apiCredentials, phoneNumber, forceSMS, reCaptchaCallback);
     }
+    /**
+     * Sends an email verification code for login setup.
+     * This is used when Telegram requires email verification during login.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param email - The email address to verify
+     * @returns The email pattern and code length
+     * @example
+     * ```ts
+     * const result = await client.sendVerifyEmailCode(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     "user@example.com"
+     * );
+     * console.log(`Code sent to ${result.emailPattern}, length: ${result.length}`);
+     * ```
+     */
+    sendVerifyEmailCode(phoneNumber, phoneCodeHash, email) {
+        return authMethods.sendVerifyEmailCode(this, phoneNumber, phoneCodeHash, email);
+    }
+    /**
+     * Verifies an email address during login setup.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param verification - The verification result (code, Google token, or Apple token)
+     * @returns The verified email and the new sent code for phone verification
+     * @example
+     * ```ts
+     * // Verify with email code
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "code", code: "12345" }
+     * );
+     *
+     * // Or verify with Google Sign-In
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "google", token: "google-id-token" }
+     * );
+     * ```
+     */
+    verifyEmail(phoneNumber, phoneCodeHash, verification) {
+        return authMethods.verifyEmail(this, phoneNumber, phoneCodeHash, verification);
+    }
+    /**
+     * Resets the login email when the user cannot access their current email.
+     * This will cancel the current email verification and allow setting up a new one.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @returns The new sent code result
+     * @example
+     * ```ts
+     * // User can't access their email, reset it
+     * const newSentCode = await client.resetLoginEmail("+1234567890", "abc123hash");
+     * ```
+     */
+    resetLoginEmail(phoneNumber, phoneCodeHash) {
+        return authMethods.resetLoginEmail(this, phoneNumber, phoneCodeHash);
+    }
     /**
      * Uses the 2FA password to sign in the account.<br/>
      * This function should be used after the user has signed in with the code they received.
@@ -862,6 +923,18 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
     listEventHandlers() {
         return updateMethods.listEventHandlers(this);
     }
+    /**
+     * Fetches and processes any updates that were missed while disconnected.
+     * Call this after reconnecting to ensure no updates are lost.
+     * @example
+     * ```ts
+     * await client.connect();
+     * await client.catchUp(); // Fetch missed updates
+     * ```
+     */
+    async catchUp() {
+        return (0, updates_1.catchUp)(this);
+    }
     // region uploads
     /**
      * Uploads a file to Telegram's servers, without sending it.

package/client/auth.d.ts

@@ -1,5 +1,35 @@
 import { Api } from "../tl";
 import type { TelegramClient } from "./TelegramClient";
+/**
+ * Email verification options passed to the email callback.
+ */
+export interface EmailVerificationOptions {
+    /** Whether Google Sign-In is allowed for email verification. */
+    googleSigninAllowed?: boolean;
+    /** Whether Apple Sign-In is allowed for email verification. */
+    appleSigninAllowed?: boolean;
+    /** The email pattern (masked email) when code was sent to existing email. */
+    emailPattern?: string;
+    /** The code length when email code is expected. */
+    codeLength?: number;
+    /** Period in seconds after which the email can be reset. */
+    resetAvailablePeriod?: number;
+    /** Date when the pending reset will complete. */
+    resetPendingDate?: number;
+}
+/**
+ * Result from the email callback - can be code, Google token, or Apple token.
+ */
+export type EmailVerificationResult = {
+    type: "code";
+    code: string;
+} | {
+    type: "google";
+    token: string;
+} | {
+    type: "apple";
+    token: string;
+};
 /**
  * For when you want to login as a {@link Api.User}<br/>
  * this should handle all needed steps for authorization as a user.<br/>
@@ -29,6 +59,14 @@ export interface UserAuthParams {
     forceSMS?: boolean;
     /** optional callback for handling reCAPTCHA. */
     reCaptchaCallback?: (siteKey: string) => Promise<string>;
+    /** callback for email verification when Telegram requires email setup or code.<br/>
+     *  Called when `auth.SentCodeTypeSetUpEmailRequired` or `auth.SentCodeTypeEmailCode` is received.<br/>
+     *  For setup: should return email address to use and then handle verification code.<br/>
+     *  For existing email: should return the verification result (code, Google token, or Apple token). */
+    emailVerification?: (options: EmailVerificationOptions) => Promise<EmailVerificationResult>;
+    /** callback to get email address when email setup is required.<br/>
+     *  Called first when `auth.SentCodeTypeSetUpEmailRequired` is received. */
+    emailAddress?: () => Promise<string>;
 }
 export interface UserPasswordAuthParams {
     /** optional string or callback that should return the 2FA password if present.<br/>
@@ -80,16 +118,75 @@ export declare function checkAuthorization(client: TelegramClient): Promise<bool
 export declare function signInUser(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function signInUserWithQrCode(client: TelegramClient, apiCredentials: ApiCredentials, authParams: QrCodeAuthParams): Promise<Api.TypeUser>;
-/** @hidden */
-/** @hidden */
-export declare function sendCode(client: TelegramClient, apiCredentials: ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<{
+/**
+ * Result from sendCode containing info about how to proceed with verification.
+ */
+export interface SendCodeResult {
+    /** The phone code hash needed for sign in. */
     phoneCodeHash: string;
+    /** Whether the code was sent via Telegram app (true) or SMS (false). */
     isCodeViaApp: boolean;
-}>;
+    /** If true, email setup is required before phone code. */
+    emailRequired?: boolean;
+    /** If true, code was sent to existing email. */
+    emailCodeSent?: boolean;
+    /** Email verification options when email is involved. */
+    emailOptions?: EmailVerificationOptions;
+}
+/** @hidden */
+export declare function sendCode(client: TelegramClient, apiCredentials: ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<SendCodeResult>;
 /** @hidden */
 export declare function signInWithPassword(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserPasswordAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function signInBot(client: TelegramClient, apiCredentials: ApiCredentials, authParams: BotAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function _authFlow(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserAuthParams | BotAuthParams): Promise<void>;
+/**
+ * Result from sendVerifyEmailCode.
+ */
+export interface SentEmailCodeResult {
+    /** The masked email pattern where the code was sent. */
+    emailPattern: string;
+    /** The length of the verification code. */
+    length: number;
+}
+/**
+ * Sends an email verification code for login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param email - The email address to verify
+ * @returns The email pattern and code length
+ */
+/** @hidden */
+export declare function sendVerifyEmailCode(client: TelegramClient, phoneNumber: string, phoneCodeHash: string, email: string): Promise<SentEmailCodeResult>;
+/**
+ * Result from verifyEmail for login.
+ */
+export interface EmailVerifiedLoginResult {
+    /** The verified email address. */
+    email: string;
+    /** The new sent code result to continue with phone verification. */
+    sentCode: Api.auth.TypeSentCode;
+}
+/**
+ * Verifies an email address during login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param verification - The verification (code, Google token, or Apple token)
+ * @returns The verified email and the new sent code for phone verification
+ */
+/** @hidden */
+export declare function verifyEmail(client: TelegramClient, phoneNumber: string, phoneCodeHash: string, verification: EmailVerificationResult): Promise<EmailVerifiedLoginResult>;
+/**
+ * Resets the login email when the user cannot access their current email.
+ * This will cancel the current email verification and allow setting up a new one.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @returns The new sent code result
+ */
+/** @hidden */
+export declare function resetLoginEmail(client: TelegramClient, phoneNumber: string, phoneCodeHash: string): Promise<Api.auth.TypeSentCode>;
 export {};

package/client/auth.js

@@ -41,6 +41,9 @@ exports.sendCode = sendCode;
 exports.signInWithPassword = signInWithPassword;
 exports.signInBot = signInBot;
 exports._authFlow = _authFlow;
+exports.sendVerifyEmailCode = sendVerifyEmailCode;
+exports.verifyEmail = verifyEmail;
+exports.resetLoginEmail = resetLoginEmail;
 const tl_1 = require("../tl");
 const utils = __importStar(require("../Utils"));
 const Helpers_1 = require("../Helpers");
@@ -73,8 +76,8 @@ async function checkAuthorization(client) {
 }
 /** @hidden */
 async function signInUser(client, apiCredentials, authParams) {
-    let phoneNumber;
-    let phoneCodeHash;
+    let phoneNumber = "";
+    let phoneCodeHash = "";
     let isCodeViaApp = false;
     while (1) {
         try {
@@ -98,6 +101,45 @@ async function signInUser(client, apiCredentials, authParams) {
             if (typeof phoneCodeHash !== "string") {
                 throw new Error("Failed to retrieve phone code hash");
             }
+            // Handle email verification if required
+            if (sendCodeResult.emailRequired) {
+                // Email setup is required before phone code
+                if (!authParams.emailAddress || !authParams.emailVerification) {
+                    throw new Error("Email verification required but emailAddress or emailVerification callback not provided");
+                }
+                // Get email address from user
+                const email = await authParams.emailAddress();
+                // Send verification code to email
+                const emailCodeResult = await sendVerifyEmailCode(client, phoneNumber, phoneCodeHash, email);
+                // Get verification from user
+                const verification = await authParams.emailVerification(Object.assign(Object.assign({}, sendCodeResult.emailOptions), { emailPattern: emailCodeResult.emailPattern, codeLength: emailCodeResult.length }));
+                // Verify email
+                const verifyResult = await verifyEmail(client, phoneNumber, phoneCodeHash, verification);
+                // Update phone code hash from the new sent code
+                if (verifyResult.sentCode instanceof tl_1.Api.auth.SentCode) {
+                    phoneCodeHash = verifyResult.sentCode.phoneCodeHash;
+                    isCodeViaApp =
+                        verifyResult.sentCode.type instanceof
+                            tl_1.Api.auth.SentCodeTypeApp;
+                }
+            }
+            else if (sendCodeResult.emailCodeSent) {
+                // Code was sent to existing email
+                if (!authParams.emailVerification) {
+                    throw new Error("Email code sent but emailVerification callback not provided");
+                }
+                // Get verification from user for existing email
+                const verification = await authParams.emailVerification(sendCodeResult.emailOptions || {});
+                // Verify with existing email
+                const verifyResult = await verifyEmail(client, phoneNumber, phoneCodeHash, verification);
+                // Update phone code hash from the new sent code
+                if (verifyResult.sentCode instanceof tl_1.Api.auth.SentCode) {
+                    phoneCodeHash = verifyResult.sentCode.phoneCodeHash;
+                    isCodeViaApp =
+                        verifyResult.sentCode.type instanceof
+                            tl_1.Api.auth.SentCodeTypeApp;
+                }
+            }
             break;
         }
         catch (err) {
@@ -273,7 +315,6 @@ async function signInUserWithQrCode(client, apiCredentials, authParams) {
     throw new Error("QR auth failed");
 }
 /** @hidden */
-/** @hidden */
 async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, reCaptchaCallback) {
     var _a;
     try {
@@ -310,6 +351,33 @@ async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, r
                 isCodeViaApp: false,
             };
         }
+        // Handle email verification types
+        if (sendResult.type instanceof tl_1.Api.auth.SentCodeTypeSetUpEmailRequired) {
+            return {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailRequired: true,
+                emailOptions: {
+                    googleSigninAllowed: sendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: sendResult.type.appleSigninAllowed,
+                },
+            };
+        }
+        if (sendResult.type instanceof tl_1.Api.auth.SentCodeTypeEmailCode) {
+            return {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailCodeSent: true,
+                emailOptions: {
+                    googleSigninAllowed: sendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: sendResult.type.appleSigninAllowed,
+                    emailPattern: sendResult.type.emailPattern,
+                    codeLength: sendResult.type.length,
+                    resetAvailablePeriod: sendResult.type.resetAvailablePeriod,
+                    resetPendingDate: sendResult.type.resetPendingDate,
+                },
+            };
+        }
         // If we already sent a SMS, do not resend the phoneCode (hash may be empty)
         if (!forceSMS || sendResult.type instanceof tl_1.Api.auth.SentCodeTypeSms) {
             return {
@@ -329,6 +397,33 @@ async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, r
                 isCodeViaApp: false,
             };
         }
+        // Handle email types in resend result as well
+        if (resendResult.type instanceof tl_1.Api.auth.SentCodeTypeSetUpEmailRequired) {
+            return {
+                phoneCodeHash: resendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailRequired: true,
+                emailOptions: {
+                    googleSigninAllowed: resendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: resendResult.type.appleSigninAllowed,
+                },
+            };
+        }
+        if (resendResult.type instanceof tl_1.Api.auth.SentCodeTypeEmailCode) {
+            return {
+                phoneCodeHash: resendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailCodeSent: true,
+                emailOptions: {
+                    googleSigninAllowed: resendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: resendResult.type.appleSigninAllowed,
+                    emailPattern: resendResult.type.emailPattern,
+                    codeLength: resendResult.type.length,
+                    resetAvailablePeriod: resendResult.type.resetAvailablePeriod,
+                    resetPendingDate: resendResult.type.resetPendingDate,
+                },
+            };
+        }
         return {
             phoneCodeHash: resendResult.phoneCodeHash,
             isCodeViaApp: resendResult.type instanceof tl_1.Api.auth.SentCodeTypeApp,
@@ -406,3 +501,83 @@ async function _authFlow(client, apiCredentials, authParams) {
         : await client.signInBot(apiCredentials, authParams);
     client._log.info("Signed in successfully as " + utils.getDisplayName(me));
 }
+/**
+ * Sends an email verification code for login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param email - The email address to verify
+ * @returns The email pattern and code length
+ */
+/** @hidden */
+async function sendVerifyEmailCode(client, phoneNumber, phoneCodeHash, email) {
+    const result = await client.invoke(new tl_1.Api.account.SendVerifyEmailCode({
+        purpose: new tl_1.Api.EmailVerifyPurposeLoginSetup({
+            phoneNumber,
+            phoneCodeHash,
+        }),
+        email,
+    }));
+    return {
+        emailPattern: result.emailPattern,
+        length: result.length,
+    };
+}
+/**
+ * Verifies an email address during login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param verification - The verification (code, Google token, or Apple token)
+ * @returns The verified email and the new sent code for phone verification
+ */
+/** @hidden */
+async function verifyEmail(client, phoneNumber, phoneCodeHash, verification) {
+    let emailVerification;
+    switch (verification.type) {
+        case "code":
+            emailVerification = new tl_1.Api.EmailVerificationCode({
+                code: verification.code,
+            });
+            break;
+        case "google":
+            emailVerification = new tl_1.Api.EmailVerificationGoogle({
+                token: verification.token,
+            });
+            break;
+        case "apple":
+            emailVerification = new tl_1.Api.EmailVerificationApple({
+                token: verification.token,
+            });
+            break;
+    }
+    const result = await client.invoke(new tl_1.Api.account.VerifyEmail({
+        purpose: new tl_1.Api.EmailVerifyPurposeLoginSetup({
+            phoneNumber,
+            phoneCodeHash,
+        }),
+        verification: emailVerification,
+    }));
+    if (!(result instanceof tl_1.Api.account.EmailVerifiedLogin)) {
+        throw new Error("Expected EmailVerifiedLogin but got " + result.className);
+    }
+    return {
+        email: result.email,
+        sentCode: result.sentCode,
+    };
+}
+/**
+ * Resets the login email when the user cannot access their current email.
+ * This will cancel the current email verification and allow setting up a new one.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @returns The new sent code result
+ */
+/** @hidden */
+async function resetLoginEmail(client, phoneNumber, phoneCodeHash) {
+    return await client.invoke(new tl_1.Api.auth.ResetLoginEmail({
+        phoneNumber,
+        phoneCodeHash,
+    }));
+}

package/client/telegramBaseClient.d.ts

@@ -181,6 +181,13 @@ export declare abstract class TelegramBaseClient {
     /** @hidden */
     protected _loopStarted: boolean;
     /** @hidden */
+    _updateState?: {
+        pts: number;
+        qts: number;
+        date: number;
+        seq: number;
+    };
+    /** @hidden */
     _reconnecting: boolean;
     /** @hidden */
     _destroyed: boolean;

package/client/telegramBaseClient.js

@@ -182,6 +182,7 @@ class TelegramBaseClient {
     }
     async _disconnect() {
         var _a;
+        this._loopStarted = false;
         await ((_a = this._sender) === null || _a === void 0 ? void 0 : _a.disconnect());
     }
     /**

package/client/updates.d.ts

@@ -19,8 +19,11 @@ export declare function addEventHandler(client: TelegramClient, callback: Callab
 export declare function removeEventHandler(client: TelegramClient, callback: CallableFunction, event: EventBuilder): void;
 /** @hidden */
 export declare function listEventHandlers(client: TelegramClient): [EventBuilder, CallableFunction][];
-/** @hidden */
-export declare function catchUp(): void;
+/**
+ * Fetches and processes any updates that were missed while disconnected.
+ * Call this after reconnecting to ensure no updates are lost.
+ */
+export declare function catchUp(client: TelegramClient): Promise<void>;
 /** @hidden */
 export declare function _handleUpdate(client: TelegramClient, update: Api.TypeUpdate | number): void;
 /** @hidden */

package/client/updates.js

@@ -14,7 +14,6 @@ const tl_1 = require("../tl");
 const network_1 = require("../network");
 const index_1 = require("../index");
 const Helpers_1 = require("../Helpers");
-const Logger_1 = require("../extensions/Logger");
 const PING_INTERVAL = 9000; // 9 sec
 const PING_TIMEOUT = 10000; // 10 sec
 const PING_FAIL_ATTEMPTS = 3;
@@ -61,39 +60,151 @@ function removeEventHandler(client, callback, event) {
 function listEventHandlers(client) {
     return client._eventBuilders;
 }
-/** @hidden */
-function catchUp() {
-    // TODO
+/**
+ * Fetches and processes any updates that were missed while disconnected.
+ * Call this after reconnecting to ensure no updates are lost.
+ */
+async function catchUp(client) {
+    try {
+        // Get current state if we don't have one
+        if (!client._updateState) {
+            const state = await client.invoke(new tl_1.Api.updates.GetState());
+            client._updateState = {
+                pts: state.pts,
+                qts: state.qts,
+                date: state.date,
+                seq: state.seq,
+            };
+            client._log.debug("Initialized update state");
+            return;
+        }
+        // Fetch missed updates
+        client._log.debug("Catching up on missed updates...");
+        let fetching = true;
+        while (fetching) {
+            const diff = await client.invoke(new tl_1.Api.updates.GetDifference({
+                pts: client._updateState.pts,
+                date: client._updateState.date,
+                qts: client._updateState.qts,
+            }));
+            if (diff instanceof tl_1.Api.updates.DifferenceEmpty) {
+                client._updateState.date = diff.date;
+                client._updateState.seq = diff.seq;
+                fetching = false;
+            }
+            else if (diff instanceof tl_1.Api.updates.Difference) {
+                // Process all missed updates
+                await _processDifference(client, diff);
+                client._updateState = {
+                    pts: diff.state.pts,
+                    qts: diff.state.qts,
+                    date: diff.state.date,
+                    seq: diff.state.seq,
+                };
+                fetching = false;
+            }
+            else if (diff instanceof tl_1.Api.updates.DifferenceSlice) {
+                // Process partial updates, continue fetching
+                await _processDifference(client, diff);
+                client._updateState = {
+                    pts: diff.intermediateState.pts,
+                    qts: diff.intermediateState.qts,
+                    date: diff.intermediateState.date,
+                    seq: diff.intermediateState.seq,
+                };
+                // Continue loop to fetch more
+            }
+            else if (diff instanceof tl_1.Api.updates.DifferenceTooLong) {
+                // Too many updates missed, just update pts and continue
+                client._updateState.pts = diff.pts;
+                fetching = false;
+                client._log.warn("Too many updates missed, some may be lost");
+            }
+        }
+        client._log.debug("Catch up complete");
+    }
+    catch (e) {
+        client._log.error(`Error during catch up: ${e}`);
+    }
 }
 /** @hidden */
-function _handleUpdate(client, update) {
-    if (typeof update === "number") {
-        if ([-1, 0, 1].includes(update)) {
-            _dispatchUpdate(client, {
-                update: new network_1.UpdateConnectionState(update),
-            });
-            return;
+async function _processDifference(client, diff) {
+    // Build entities map
+    const entities = new Map();
+    for (const user of diff.users) {
+        try {
+            entities.set(index_1.utils.getPeerId(user), user);
+        }
+        catch (e) {
+            // Skip invalid
         }
     }
-    //this.session.processEntities(update)
-    client._entityCache.add(update);
-    client.session.processEntities(update);
-    if (update instanceof tl_1.Api.Updates ||
-        update instanceof tl_1.Api.UpdatesCombined) {
-        // TODO deal with entities
-        const entities = new Map();
-        for (const x of [...update.users, ...update.chats]) {
-            entities.set(index_1.utils.getPeerId(x), x);
+    for (const chat of diff.chats) {
+        try {
+            entities.set(index_1.utils.getPeerId(chat), chat);
         }
-        for (const u of update.updates) {
-            _processUpdate(client, u, update.updates, entities);
+        catch (e) {
+            // Skip invalid
         }
     }
-    else if (update instanceof tl_1.Api.UpdateShort) {
-        _processUpdate(client, update.update, null);
+    // Process entities
+    client._entityCache.add(diff);
+    client.session.processEntities(diff);
+    // Process new messages as updates
+    for (const message of diff.newMessages) {
+        if (message instanceof tl_1.Api.Message || message instanceof tl_1.Api.MessageService) {
+            const update = new tl_1.Api.UpdateNewMessage({
+                message: message,
+                pts: 0,
+                ptsCount: 0,
+            });
+            _processUpdate(client, update, null, entities);
+        }
     }
-    else {
-        _processUpdate(client, update, null);
+    // Process other updates
+    for (const update of diff.otherUpdates) {
+        _processUpdate(client, update, diff.otherUpdates, entities);
+    }
+}
+/** @hidden */
+function _handleUpdate(client, update) {
+    try {
+        if (typeof update === "number") {
+            if ([-1, 0, 1].includes(update)) {
+                _dispatchUpdate(client, {
+                    update: new network_1.UpdateConnectionState(update),
+                }).catch((e) => {
+                    client._log.error(`Error dispatching connection state: ${e}`);
+                });
+                return;
+            }
+        }
+        client._entityCache.add(update);
+        client.session.processEntities(update);
+        if (update instanceof tl_1.Api.Updates ||
+            update instanceof tl_1.Api.UpdatesCombined) {
+            const entities = new Map();
+            for (const x of [...update.users, ...update.chats]) {
+                try {
+                    entities.set(index_1.utils.getPeerId(x), x);
+                }
+                catch (e) {
+                    // Skip invalid entity
+                }
+            }
+            for (const u of update.updates) {
+                _processUpdate(client, u, update.updates, entities);
+            }
+        }
+        else if (update instanceof tl_1.Api.UpdateShort) {
+            _processUpdate(client, update.update, null);
+        }
+        else {
+            _processUpdate(client, update, null);
+        }
+    }
+    catch (e) {
+        client._log.error(`Error handling update: ${e}`);
     }
 }
 /** @hidden */
@@ -103,7 +214,9 @@ function _processUpdate(client, update, others, entities) {
         update: update,
         others: others,
     };
-    _dispatchUpdate(client, args);
+    _dispatchUpdate(client, args).catch((e) => {
+        client._log.error(`Error dispatching update: ${e}`);
+    });
 }
 /** @hidden */
 async function _dispatchUpdate(client, args) {
@@ -111,8 +224,14 @@ async function _dispatchUpdate(client, args) {
         if (!builder || !callback) {
             continue;
         }
-        if (!builder.resolved) {
-            await builder.resolve(client);
+        try {
+            if (!builder.resolved) {
+                await builder.resolve(client);
+            }
+        }
+        catch (e) {
+            client._log.error(`Error resolving event builder: ${e}`);
+            continue;
         }
         let event = args.update;
         if (event) {
@@ -128,9 +247,15 @@ async function _dispatchUpdate(client, args) {
                 // TODO fix me
             }
             // TODO fix others not being passed
-            event = builder.build(event, callback, client._selfInputPeer
-                ? (0, Helpers_1.returnBigInt)(client._selfInputPeer.userId)
-                : undefined);
+            try {
+                event = builder.build(event, callback, client._selfInputPeer
+                    ? (0, Helpers_1.returnBigInt)(client._selfInputPeer.userId)
+                    : undefined);
+            }
+            catch (e) {
+                client._log.error(`Error building event: ${e}`);
+                continue;
+            }
             if (event) {
                 event._client = client;
                 if ("_eventName" in event) {
@@ -138,7 +263,14 @@ async function _dispatchUpdate(client, args) {
                     event.originalUpdate = args.update;
                     event._entities = args.update._entities;
                 }
-                const filter = await builder.filter(event);
+                let filter;
+                try {
+                    filter = await builder.filter(event);
+                }
+                catch (e) {
+                    client._log.error(`Error in event filter: ${e}`);
+                    continue;
+                }
                 if (!filter) {
                     continue;
                 }
@@ -152,12 +284,7 @@ async function _dispatchUpdate(client, args) {
                     if (client._errorHandler) {
                         await client._errorHandler(e);
                     }
-                    if (client._log && typeof client._log.canSend === 'function' && client._log.canSend(Logger_1.LogLevel.ERROR)) {
-                        console.error(e);
-                    }
-                    else if (client._log) {
-                        console.error(e);
-                    }
+                    client._log.error(`Error in event handler: ${e}`);
                 }
             }
         }
@@ -165,10 +292,26 @@ async function _dispatchUpdate(client, args) {
 }
 /** @hidden */
 async function _updateLoop(client) {
+    // Initialize update state on first run
+    if (!client._updateState) {
+        try {
+            const state = await client.invoke(new tl_1.Api.updates.GetState());
+            client._updateState = {
+                pts: state.pts,
+                qts: state.qts,
+                date: state.date,
+                seq: state.seq,
+            };
+            client._log.debug("Initialized update state");
+        }
+        catch (e) {
+            client._log.error(`Failed to get initial update state: ${e}`);
+        }
+    }
     let lastPongAt;
     while (!client._destroyed) {
         await (0, Helpers_1.sleep)(PING_INTERVAL, true);
-        if (client._destroyed)
+        if (client._destroyed || client.disconnected)
             break;
         if (client._sender.isReconnecting || client._isSwitchingDc) {
             lastPongAt = undefined;
@@ -201,17 +344,14 @@ async function _updateLoop(client) {
             lastPongAt = Date.now();
         }
         catch (err) {
-            // eslint-disable-next-line no-console
             if (client._errorHandler) {
                 await client._errorHandler(err);
             }
-            if (client._log && typeof client._log.canSend === 'function' && client._log.canSend(Logger_1.LogLevel.ERROR)) {
-                console.error(err);
-            }
-            else if (client._log) {
-                console.error(err);
-            }
+            client._log.error(`Ping failed: ${err}`);
             lastPongAt = undefined;
+            if (client.disconnected || client._destroyed) {
+                break;
+            }
             if (client._sender.isReconnecting || client._isSwitchingDc) {
                 continue;
             }
@@ -222,7 +362,14 @@ async function _updateLoop(client) {
         // just stop even if we're connected. Do so every 30 minutes.
         if (Date.now() - (client._lastRequest || 0) > 30 * 60 * 1000) {
             try {
-                await client.invoke(new tl_1.Api.updates.GetState());
+                const state = await client.invoke(new tl_1.Api.updates.GetState());
+                // Update our state to stay in sync
+                if (client._updateState) {
+                    client._updateState.pts = state.pts;
+                    client._updateState.qts = state.qts;
+                    client._updateState.date = state.date;
+                    client._updateState.seq = state.seq;
+                }
             }
             catch (e) {
                 // we don't care about errors here

package/client/uploads.d.ts

@@ -130,7 +130,7 @@ export declare function _fileToMedia(client: TelegramClient, { file, forceDocume
     image?: boolean;
 }>;
 /** @hidden */
-export declare function _sendAlbum(client: TelegramClient, entity: EntityLike, { file, caption, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote, videoNote, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
+export declare function _sendAlbum(client: TelegramClient, entity: EntityLike, { file, caption, formattingEntities, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote, videoNote, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
 /** @hidden */
 export declare function sendFile(client: TelegramClient, entity: EntityLike, { file, caption, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, formattingEntities, voiceNote, videoNote, buttons, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
 export {};

package/client/uploads.js

@@ -318,7 +318,7 @@ async function _fileToMedia(client, { file, forceDocument, fileSize, progressCal
     };
 }
 /** @hidden */
-async function _sendAlbum(client, entity, { file, caption, forceDocument = false, fileSize, clearDraft = false, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote = false, videoNote = false, silent, supportsStreaming = false, scheduleDate, workers = 1, noforwards, commentTo, topMsgId, }) {
+async function _sendAlbum(client, entity, { file, caption, formattingEntities, forceDocument = false, fileSize, clearDraft = false, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote = false, videoNote = false, silent, supportsStreaming = false, scheduleDate, workers = 1, noforwards, commentTo, topMsgId, }) {
     entity = await client.getInputEntity(entity);
     let files = [];
     if (!Array.isArray(file)) {
@@ -334,8 +334,13 @@ async function _sendAlbum(client, entity, { file, caption, forceDocument = false
         caption = [caption];
     }
     const captions = [];
-    for (const c of caption) {
-        captions.push(await (0, messageParse_1._parseMessageText)(client, c, parseMode));
+    for (const [i, c] of caption.entries()) {
+        if (i === 0 && formattingEntities) {
+            captions.push([c || "", formattingEntities]);
+        }
+        else {
+            captions.push(await (0, messageParse_1._parseMessageText)(client, c, parseMode));
+        }
     }
     if (commentTo != undefined) {
         const discussionData = await (0, messages_1.getCommentData)(client, entity, commentTo);
@@ -440,6 +445,7 @@ async function sendFile(client, entity, { file, caption, forceDocument = false,
         return await _sendAlbum(client, entity, {
             file: file,
             caption: caption,
+            formattingEntities: formattingEntities,
             replyTo: replyTo,
             parseMode: parseMode,
             attributes: attributes,

package/index.d.ts

@@ -11,4 +11,5 @@ import * as extensions from "./extensions";
 import * as helpers from "./Helpers";
 import * as client from "./client";
 import * as password from "./Password";
-export { utils, errors, sessions, extensions, helpers, tl, password, client };
+import * as events from "./events";
+export { utils, errors, sessions, extensions, helpers, tl, password, client, events };

package/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.client = exports.password = exports.tl = exports.helpers = exports.extensions = exports.sessions = exports.errors = exports.utils = exports.Logger = exports.version = exports.Connection = exports.TelegramClient = exports.Api = void 0;
+exports.events = exports.client = exports.password = exports.tl = exports.helpers = exports.extensions = exports.sessions = exports.errors = exports.utils = exports.Logger = exports.version = exports.Connection = exports.TelegramClient = exports.Api = void 0;
 var tl_1 = require("./tl");
 Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return tl_1.Api; } });
 const tl = __importStar(require("./tl"));
@@ -60,3 +60,5 @@ const client = __importStar(require("./client"));
 exports.client = client;
 const password = __importStar(require("./Password"));
 exports.password = password;
+const events = __importStar(require("./events"));
+exports.events = events;

package/network/MTProtoSender.js

@@ -254,6 +254,7 @@ class MTProtoSender {
             this._log.debug("Already have an auth key ...");
         }
         this._userConnected = true;
+        this._disconnected = false;
         this.isReconnecting = false;
         if (!this._sendLoopHandle) {
             this._log.debug("Starting send loop");
@@ -279,6 +280,7 @@ class MTProtoSender {
         }
         this._log.info("Disconnecting from %s...".replace("%s", connection.toString()));
         this._userConnected = false;
+        this._disconnected = true;
         this._log.debug("Closing current connection...");
         // Signal abort to any ongoing operations
         this._abortController.abort();

package/package.json

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