teleproto 203.0.0

package/client/account.js

@@ -0,0 +1 @@
+"use strict";

package/client/auth.d.ts

@@ -0,0 +1,93 @@
+/// <reference types="node" />
+import { Api } from "../tl";
+import type { TelegramClient } from "./TelegramClient";
+/**
+ * For when you want to login as a {@link Api.User}<br/>
+ * this should handle all needed steps for authorization as a user.<br/>
+ * to stop the operation at any point just raise and error with the message `AUTH_USER_CANCEL`.
+ */
+export interface UserAuthParams {
+    /** Either a string or a callback that returns a string for the phone to use to login. */
+    phoneNumber: string | (() => Promise<string>);
+    /** callback that should return the login code that telegram sent.<br/>
+     *  has optional bool `isCodeViaApp` param for whether the code was sent through the app (true) or an SMS (false). */
+    phoneCode: (isCodeViaApp?: boolean) => Promise<string>;
+    /** optional string or callback that should return the 2FA password if present.<br/>
+     *  the password hint will be sent in the hint param */
+    password?: (hint?: string) => Promise<string>;
+    /** in case of a new account creation this callback should return a first name and last name `[first,last]`. */
+    firstAndLastNames?: () => Promise<[string, string?]>;
+    /** a qrCode token for login through qrCode.<br/>
+     *  this would need a QR code that you should scan with another app to login with. */
+    qrCode?: (qrCode: {
+        token: Buffer;
+        expires: number;
+    }) => Promise<void>;
+    /** when an error happens during auth this function will be called with the error.<br/>
+     *  if this returns true the auth operation will stop. */
+    onError: (err: Error) => Promise<boolean> | void;
+    /** whether to send the code through SMS or not. */
+    forceSMS?: boolean;
+}
+export interface UserPasswordAuthParams {
+    /** optional string or callback that should return the 2FA password if present.<br/>
+     *  the password hint will be sent in the hint param */
+    password?: (hint?: string) => Promise<string>;
+    /** when an error happens during auth this function will be called with the error.<br/>
+     *  if this returns true the auth operation will stop. */
+    onError: (err: Error) => Promise<boolean> | void;
+}
+export interface QrCodeAuthParams extends UserPasswordAuthParams {
+    /** a qrCode token for login through qrCode.<br/>
+     *  this would need a QR code that you should scan with another app to login with. */
+    qrCode?: (qrCode: {
+        token: Buffer;
+        expires: number;
+    }) => Promise<void>;
+    /** when an error happens during auth this function will be called with the error.<br/>
+     *  if this returns true the auth operation will stop. */
+    onError: (err: Error) => Promise<boolean> | void;
+}
+interface ReturnString {
+    (): string;
+}
+/**
+ * For when you want as a normal bot created by https://t.me/Botfather.<br/>
+ * Logging in as bot is simple and requires no callbacks
+ */
+export interface BotAuthParams {
+    /**
+     * the bot token to use.
+     */
+    botAuthToken: string | ReturnString;
+}
+/**
+ * Credential needed for the authentication. you can get theses from https://my.telegram.org/auth<br/>
+ * Note: This is required for both logging in as a bot and a user.<br/>
+ */
+export interface ApiCredentials {
+    /** The app api id. */
+    apiId: number;
+    /** the app api hash */
+    apiHash: string;
+}
+/** @hidden */
+export declare function start(client: TelegramClient, authParams: UserAuthParams | BotAuthParams): Promise<void>;
+/** @hidden */
+export declare function checkAuthorization(client: TelegramClient): Promise<boolean>;
+/** @hidden */
+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 */
+export declare function sendCode(client: TelegramClient, apiCredentials: ApiCredentials, phoneNumber: string, forceSMS?: boolean): Promise<{
+    phoneCodeHash: string;
+    isCodeViaApp: boolean;
+}>;
+/** @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>;
+export {};

package/client/auth.js

@@ -0,0 +1,375 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._authFlow = exports.signInBot = exports.signInWithPassword = exports.sendCode = exports.signInUserWithQrCode = exports.signInUser = exports.checkAuthorization = exports.start = void 0;
+const tl_1 = require("../tl");
+const utils = __importStar(require("../Utils"));
+const Helpers_1 = require("../Helpers");
+const Password_1 = require("../Password");
+const QR_CODE_TIMEOUT = 30000;
+// region public methods
+/** @hidden */
+async function start(client, authParams) {
+    if (!client.connected) {
+        await client.connect();
+    }
+    if (await client.checkAuthorization()) {
+        return;
+    }
+    const apiCredentials = {
+        apiId: client.apiId,
+        apiHash: client.apiHash,
+    };
+    await _authFlow(client, apiCredentials, authParams);
+}
+exports.start = start;
+/** @hidden */
+async function checkAuthorization(client) {
+    try {
+        await client.invoke(new tl_1.Api.updates.GetState());
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.checkAuthorization = checkAuthorization;
+/** @hidden */
+async function signInUser(client, apiCredentials, authParams) {
+    let phoneNumber;
+    let phoneCodeHash;
+    let isCodeViaApp = false;
+    while (1) {
+        try {
+            if (typeof authParams.phoneNumber === "function") {
+                try {
+                    phoneNumber = await authParams.phoneNumber();
+                }
+                catch (err) {
+                    if (err.errorMessage === "RESTART_AUTH_WITH_QR") {
+                        return client.signInUserWithQrCode(apiCredentials, authParams);
+                    }
+                    throw err;
+                }
+            }
+            else {
+                phoneNumber = authParams.phoneNumber;
+            }
+            const sendCodeResult = await client.sendCode(apiCredentials, phoneNumber, authParams.forceSMS);
+            phoneCodeHash = sendCodeResult.phoneCodeHash;
+            isCodeViaApp = sendCodeResult.isCodeViaApp;
+            if (typeof phoneCodeHash !== "string") {
+                throw new Error("Failed to retrieve phone code hash");
+            }
+            break;
+        }
+        catch (err) {
+            if (typeof authParams.phoneNumber !== "function") {
+                throw err;
+            }
+            const shouldWeStop = await authParams.onError(err);
+            if (shouldWeStop) {
+                throw new Error("AUTH_USER_CANCEL");
+            }
+        }
+    }
+    let phoneCode;
+    let isRegistrationRequired = false;
+    let termsOfService;
+    while (1) {
+        try {
+            try {
+                phoneCode = await authParams.phoneCode(isCodeViaApp);
+            }
+            catch (err) {
+                // This is the support for changing phone number from the phone code screen.
+                if (err.errorMessage === "RESTART_AUTH") {
+                    return client.signInUser(apiCredentials, authParams);
+                }
+            }
+            if (!phoneCode) {
+                throw new Error("Code is empty");
+            }
+            // May raise PhoneCodeEmptyError, PhoneCodeExpiredError,
+            // PhoneCodeHashEmptyError or PhoneCodeInvalidError.
+            const result = await client.invoke(new tl_1.Api.auth.SignIn({
+                phoneNumber,
+                phoneCodeHash,
+                phoneCode,
+            }));
+            if (result instanceof tl_1.Api.auth.AuthorizationSignUpRequired) {
+                isRegistrationRequired = true;
+                termsOfService = result.termsOfService;
+                break;
+            }
+            return result.user;
+        }
+        catch (err) {
+            if (err.errorMessage === "SESSION_PASSWORD_NEEDED") {
+                return client.signInWithPassword(apiCredentials, authParams);
+            }
+            else {
+                const shouldWeStop = await authParams.onError(err);
+                if (shouldWeStop) {
+                    throw new Error("AUTH_USER_CANCEL");
+                }
+            }
+        }
+    }
+    if (isRegistrationRequired) {
+        while (1) {
+            try {
+                let lastName;
+                let firstName = "first name";
+                if (authParams.firstAndLastNames) {
+                    const result = await authParams.firstAndLastNames();
+                    firstName = result[0];
+                    lastName = result[1];
+                }
+                if (!firstName) {
+                    throw new Error("First name is required");
+                }
+                const { user } = (await client.invoke(new tl_1.Api.auth.SignUp({
+                    phoneNumber,
+                    phoneCodeHash,
+                    firstName,
+                    lastName,
+                })));
+                if (termsOfService) {
+                    // This is a violation of Telegram rules: the user should be presented with and accept TOS.
+                    await client.invoke(new tl_1.Api.help.AcceptTermsOfService({
+                        id: termsOfService.id,
+                    }));
+                }
+                return user;
+            }
+            catch (err) {
+                const shouldWeStop = await authParams.onError(err);
+                if (shouldWeStop) {
+                    throw new Error("AUTH_USER_CANCEL");
+                }
+            }
+        }
+    }
+    await authParams.onError(new Error("Auth failed"));
+    return client.signInUser(apiCredentials, authParams);
+}
+exports.signInUser = signInUser;
+/** @hidden */
+async function signInUserWithQrCode(client, apiCredentials, authParams) {
+    let isScanningComplete = false;
+    if (authParams.qrCode == undefined) {
+        throw new Error("qrCode callback not defined");
+    }
+    const inputPromise = (async () => {
+        while (1) {
+            if (isScanningComplete) {
+                break;
+            }
+            const result = await client.invoke(new tl_1.Api.auth.ExportLoginToken({
+                apiId: Number(apiCredentials.apiId),
+                apiHash: apiCredentials.apiHash,
+                exceptIds: [],
+            }));
+            if (!(result instanceof tl_1.Api.auth.LoginToken)) {
+                throw new Error("Unexpected");
+            }
+            const { token, expires } = result;
+            await Promise.race([
+                authParams.qrCode({ token, expires }),
+                (0, Helpers_1.sleep)(QR_CODE_TIMEOUT),
+            ]);
+            await (0, Helpers_1.sleep)(QR_CODE_TIMEOUT);
+        }
+    })();
+    const updatePromise = new Promise((resolve) => {
+        client.addEventHandler((update) => {
+            if (update instanceof tl_1.Api.UpdateLoginToken) {
+                resolve(undefined);
+            }
+        });
+    });
+    try {
+        await Promise.race([updatePromise, inputPromise]);
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        isScanningComplete = true;
+    }
+    try {
+        const result2 = await client.invoke(new tl_1.Api.auth.ExportLoginToken({
+            apiId: Number(apiCredentials.apiId),
+            apiHash: apiCredentials.apiHash,
+            exceptIds: [],
+        }));
+        if (result2 instanceof tl_1.Api.auth.LoginTokenSuccess &&
+            result2.authorization instanceof tl_1.Api.auth.Authorization) {
+            return result2.authorization.user;
+        }
+        else if (result2 instanceof tl_1.Api.auth.LoginTokenMigrateTo) {
+            await client._switchDC(result2.dcId);
+            const migratedResult = await client.invoke(new tl_1.Api.auth.ImportLoginToken({
+                token: result2.token,
+            }));
+            if (migratedResult instanceof tl_1.Api.auth.LoginTokenSuccess &&
+                migratedResult.authorization instanceof tl_1.Api.auth.Authorization) {
+                return migratedResult.authorization.user;
+            }
+            else {
+                client._log.error(`Received unknown result while scanning QR ${result2.className}`);
+                throw new Error(`Received unknown result while scanning QR ${result2.className}`);
+            }
+        }
+        else {
+            client._log.error(`Received unknown result while scanning QR ${result2.className}`);
+            throw new Error(`Received unknown result while scanning QR ${result2.className}`);
+        }
+    }
+    catch (err) {
+        if (err.errorMessage === "SESSION_PASSWORD_NEEDED") {
+            return client.signInWithPassword(apiCredentials, authParams);
+        }
+        throw err;
+    }
+    await authParams.onError(new Error("QR auth failed"));
+    throw new Error("QR auth failed");
+}
+exports.signInUserWithQrCode = signInUserWithQrCode;
+/** @hidden */
+async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false) {
+    try {
+        const { apiId, apiHash } = apiCredentials;
+        const sendResult = await client.invoke(new tl_1.Api.auth.SendCode({
+            phoneNumber,
+            apiId,
+            apiHash,
+            settings: new tl_1.Api.CodeSettings({}),
+        }));
+        if (sendResult instanceof tl_1.Api.auth.SentCodeSuccess)
+            throw new Error("logged in right after sending the code");
+        if (!(sendResult instanceof tl_1.Api.auth.SentCode)) {
+            return {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: false,
+            };
+        }
+        // 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 {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: sendResult.type instanceof tl_1.Api.auth.SentCodeTypeApp,
+            };
+        }
+        const resendResult = await client.invoke(new tl_1.Api.auth.ResendCode({
+            phoneNumber,
+            phoneCodeHash: sendResult.phoneCodeHash,
+        }));
+        if (resendResult instanceof tl_1.Api.auth.SentCodeSuccess)
+            throw new Error("logged in right after resending the code");
+        if (!(resendResult instanceof tl_1.Api.auth.SentCode)) {
+            return {
+                phoneCodeHash: resendResult.phoneCodeHash,
+                isCodeViaApp: false,
+            };
+        }
+        return {
+            phoneCodeHash: resendResult.phoneCodeHash,
+            isCodeViaApp: resendResult.type instanceof tl_1.Api.auth.SentCodeTypeApp,
+        };
+    }
+    catch (err) {
+        if (err.errorMessage === "AUTH_RESTART") {
+            return client.sendCode(apiCredentials, phoneNumber, forceSMS);
+        }
+        else {
+            throw err;
+        }
+    }
+}
+exports.sendCode = sendCode;
+/** @hidden */
+async function signInWithPassword(client, apiCredentials, authParams) {
+    let emptyPassword = false;
+    while (1) {
+        try {
+            const passwordSrpResult = await client.invoke(new tl_1.Api.account.GetPassword());
+            if (!authParams.password) {
+                emptyPassword = true;
+                break;
+            }
+            const password = await authParams.password(passwordSrpResult.hint);
+            if (!password) {
+                throw new Error("Password is empty");
+            }
+            const passwordSrpCheck = await (0, Password_1.computeCheck)(passwordSrpResult, password);
+            const { user } = (await client.invoke(new tl_1.Api.auth.CheckPassword({
+                password: passwordSrpCheck,
+            })));
+            return user;
+        }
+        catch (err) {
+            const shouldWeStop = await authParams.onError(err);
+            if (shouldWeStop) {
+                throw new Error("AUTH_USER_CANCEL");
+            }
+        }
+    }
+    if (emptyPassword) {
+        throw new Error("Account has 2FA enabled.");
+    }
+    return undefined; // Never reached (TypeScript fix)
+}
+exports.signInWithPassword = signInWithPassword;
+/** @hidden */
+async function signInBot(client, apiCredentials, authParams) {
+    const { apiId, apiHash } = apiCredentials;
+    let { botAuthToken } = authParams;
+    if (!botAuthToken) {
+        throw new Error("a valid BotToken is required");
+    }
+    if (typeof botAuthToken === "function") {
+        let token;
+        while (true) {
+            token = await botAuthToken();
+            if (token) {
+                botAuthToken = token;
+                break;
+            }
+        }
+    }
+    const { user } = (await client.invoke(new tl_1.Api.auth.ImportBotAuthorization({
+        apiId,
+        apiHash,
+        botAuthToken,
+    })));
+    return user;
+}
+exports.signInBot = signInBot;
+/** @hidden */
+async function _authFlow(client, apiCredentials, authParams) {
+    const me = "phoneNumber" in authParams
+        ? await client.signInUser(apiCredentials, authParams)
+        : await client.signInBot(apiCredentials, authParams);
+    client._log.info("Signed in successfully as " + utils.getDisplayName(me));
+}
+exports._authFlow = _authFlow;

package/client/bots.d.ts

@@ -0,0 +1,6 @@
+import type { EntityLike } from "../define";
+import { Api } from "../tl";
+import { InlineResults } from "../tl/custom/inlineResults";
+import type { TelegramClient } from "./TelegramClient";
+/** @hidden */
+export declare function inlineQuery(client: TelegramClient, bot: EntityLike, query: string, entity?: Api.InputPeerSelf, offset?: string, geoPoint?: Api.TypeInputGeoPoint): Promise<InlineResults>;

package/client/bots.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineQuery = void 0;
+const tl_1 = require("../tl");
+const inlineResults_1 = require("../tl/custom/inlineResults");
+var GetInlineBotResults = tl_1.Api.messages.GetInlineBotResults;
+// BotMethods
+/** @hidden */
+async function inlineQuery(client, bot, query, entity, offset, geoPoint) {
+    bot = await client.getInputEntity(bot);
+    let peer = new tl_1.Api.InputPeerSelf();
+    if (entity) {
+        peer = await client.getInputEntity(entity);
+    }
+    const result = await client.invoke(new GetInlineBotResults({
+        bot: bot,
+        peer: peer,
+        query: query,
+        offset: offset || "",
+        geoPoint: geoPoint,
+    }));
+    return new inlineResults_1.InlineResults(client, result, entity ? peer : undefined);
+}
+exports.inlineQuery = inlineQuery;

package/client/buttons.d.ts

@@ -0,0 +1,4 @@
+import { Api } from "../tl";
+import type { ButtonLike } from "../define";
+/** @hidden */
+export declare function buildReplyMarkup(buttons: Api.TypeReplyMarkup | undefined | ButtonLike | ButtonLike[] | ButtonLike[][], inlineOnly?: boolean): Api.TypeReplyMarkup | undefined;

package/client/buttons.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReplyMarkup = void 0;
+const tl_1 = require("../tl");
+const button_1 = require("../tl/custom/button");
+const messageButton_1 = require("../tl/custom/messageButton");
+const Helpers_1 = require("../Helpers");
+// ButtonMethods
+/** @hidden */
+function buildReplyMarkup(buttons, inlineOnly = false) {
+    if (buttons == undefined) {
+        return undefined;
+    }
+    if ("SUBCLASS_OF_ID" in buttons) {
+        if (buttons.SUBCLASS_OF_ID == 0xe2e10ef2) {
+            return buttons;
+        }
+    }
+    if (!(0, Helpers_1.isArrayLike)(buttons)) {
+        buttons = [[buttons]];
+    }
+    else if (!buttons || !(0, Helpers_1.isArrayLike)(buttons[0])) {
+        // @ts-ignore
+        buttons = [buttons];
+    }
+    let isInline = false;
+    let isNormal = false;
+    let resize = undefined;
+    const singleUse = false;
+    const selective = false;
+    const rows = [];
+    // @ts-ignore
+    for (const row of buttons) {
+        const current = [];
+        for (let button of row) {
+            if (button instanceof button_1.Button) {
+                if (button.resize != undefined) {
+                    resize = button.resize;
+                }
+                if (button.singleUse != undefined) {
+                    resize = button.singleUse;
+                }
+                if (button.selective != undefined) {
+                    resize = button.selective;
+                }
+                button = button.button;
+            }
+            else if (button instanceof messageButton_1.MessageButton) {
+                button = button.button;
+            }
+            const inline = button_1.Button._isInline(button);
+            if (!isInline && inline) {
+                isInline = true;
+            }
+            if (!isNormal && inline) {
+                isNormal = false;
+            }
+            if (button.SUBCLASS_OF_ID == 0xbad74a3) {
+                // 0xbad74a3 == crc32(b'KeyboardButton')
+                current.push(button);
+            }
+        }
+        if (current) {
+            rows.push(new tl_1.Api.KeyboardButtonRow({
+                buttons: current,
+            }));
+        }
+    }
+    if (inlineOnly && isNormal) {
+        throw new Error("You cannot use non-inline buttons here");
+    }
+    else if (isInline === isNormal && isNormal) {
+        throw new Error("You cannot mix inline with normal buttons");
+    }
+    else if (isInline) {
+        return new tl_1.Api.ReplyInlineMarkup({
+            rows: rows,
+        });
+    }
+    return new tl_1.Api.ReplyKeyboardMarkup({
+        rows: rows,
+        resize: resize,
+        singleUse: singleUse,
+        selective: selective,
+    });
+}
+exports.buildReplyMarkup = buildReplyMarkup;

package/client/chats.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import type { TelegramClient } from "./TelegramClient";
+import type { EntityLike } from "../define";
+import { TotalList } from "../Helpers";
+import { RequestIter } from "../requestIter";
+import { Api } from "../tl";
+import { inspect } from "../inspect";
+interface ParticipantsIterInterface {
+    entity: EntityLike;
+    filter: any;
+    offset?: number;
+    search?: string;
+    showTotal?: boolean;
+}
+export declare class _ParticipantsIter extends RequestIter {
+    private filterEntity;
+    private requests?;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    _init({ entity, filter, offset, search, showTotal, }: ParticipantsIterInterface): Promise<boolean | void>;
+    _loadNextChunk(): Promise<boolean | undefined>;
+    [Symbol.asyncIterator](): AsyncIterator<Api.User, any, undefined>;
+}
+/**
+ * Used in iterParticipant and getParticipant. all params are optional.
+ */
+export interface IterParticipantsParams {
+    /** how many members to retrieve. defaults to Number.MAX_SAFE_INTEGER (everyone) */
+    limit?: number;
+    /** how many members to skip. defaults to 0 */
+    offset?: number;
+    /** a query string to filter participants based on their display names and usernames. defaults to "" (everyone) */
+    search?: string;
+    /** optional filter to be used. E.g only admins filter or only banned members filter. PS : some filters need more permissions. */
+    filter?: Api.TypeChannelParticipantsFilter;
+    /** whether to call an extra request (GetFullChannel) to show the total of users in the group/channel. if set to false total will be 0 */
+    showTotal?: boolean;
+}
+/** @hidden */
+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 {};