@mtkruto/node 0.0.821 → 0.0.822

package/esm/client/client.d.ts

@@ -4,16 +4,43 @@ import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { Session } from "../session/session.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
-export interface AuthorizeUserParams<S = string, N = {
-    first: S;
-    last: S;
-}> {
+export declare const restartAuth: unique symbol;
+export interface AuthorizeUserParams<S = string> {
     phone: S | (() => MaybePromise<S>);
     code: S | (() => MaybePromise<S>);
     password: S | (() => MaybePromise<S>);
-    names: N | (() => MaybePromise<N>);
 }
 export type UpdatesHandler = null | ((client: Client, update: types.Updates) => MaybePromise<void>);
+export interface ClientParams {
+    /**
+     * The transport provider to use. Defaults to `defaultTransportProvider`.
+     */
+    transportProvider?: TransportProvider;
+    /**
+     * The app_version parameter to be passed to initConnection when calling `authorize`.
+     */
+    appVersion?: string;
+    /**
+     * The device_version parameter to be passed to initConnection when calling `authorize`.
+     */
+    deviceModel?: string;
+    /**
+     * The lang_code parameter to be passed to initConnection when calling `authorize`.
+     */
+    langCode?: string;
+    /**
+     * The lang_pack parameter to be passed to initConnection when calling `authorize`.
+     */
+    langPack?: string;
+    /**
+     * The system_lang_cde parameter to be passed to initConnection when calling `authorize`.
+     */
+    systemLangCode?: string;
+    /**
+     * The system_version parameter to be passed to initConnection when calling `authorize`.
+     */
+    systemVersion?: string;
+}
 export declare class Client extends ClientAbstract {
     readonly session: Session;
     readonly apiId: number;
@@ -29,22 +56,59 @@ export declare class Client extends ClientAbstract {
     readonly langPack: string;
     readonly systemLangCode: string;
     readonly systemVersion: string;
-    constructor(session?: Session, apiId?: number, apiHash?: string, params?: {
-        transportProvider?: TransportProvider;
-        appVersion?: string;
-        deviceModel?: string;
-        langCode?: string;
-        langPack?: string;
-        systemLangCode?: string;
-        systemVersion?: string;
-    });
+    /**
+     * Constructs the client.
+     *
+     * @param session The session provider to use. Defaults to in-memory session.
+     * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
+     * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Default to empty string (unset).
+     * @param params Other parameters.
+     */
+    constructor(session?: Session, apiId?: number, apiHash?: string, params?: ClientParams);
     private shouldLoadSession;
+    /**
+     * Sets the DC and resets the auth key stored in the session provider
+     * if the stored DC was not the same as the `dc` parameter.
+     *
+     * @param dc The DC to change to.
+     */
     setDc(dc: DC): void;
+    /**
+     * Loads the session if `setDc` was not called, initializes and connnects
+     * a `ClientPlain` to generate auth key if there was none, and connects the client.
+     * Before establishing the connection, the session is saved.
+     */
     connect(): Promise<void>;
+    /**
+     * Calls [initConnection](1) and authorizes the client with one of the following:
+     *
+     * - Bot token (`string`)
+     * - Exported authorization (`types.AuthExportedAuthorization`)
+     * - User authorization handlers (`AuthorizeUserParams`)
+     *
+     * if the current auth key doesn't throw AUTH_KEY_UNREGISTERED when calling [updates.getState](2).
+     *
+     * Notes:
+     * 1. Requires the `apiId` and `apiHash` paramters to be passed when constructing the client.
+     * 2. Reconnects the client to the appropriate DC in case of MIGRATE_X errors.
+     * 3. The parameters passed to the [initConnection][1] call can be configured with the last parameter of the constructor.
+     *
+     * [1]: https://core.telegram.org/method/initConnection
+     * [2]: https://core.telegram.org/method/updates.getState
+     */
     authorize(params: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
     private receiveLoop;
     private pingLoop;
+    /**
+     * Invokes a function waiting and returning its reply if the second parameter is not `true`. Requires the client
+     * to be connected.
+     *
+     * @param function_ The function to invoke.
+     */
     invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
     invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    /**
+     * Alias for `invoke` with its second parameter being `true`.
+     */
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
 }

package/esm/client/client.js

@@ -2,6 +2,7 @@ import { gunzip } from "../deps.js";
 import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER } from "../constants.js";
 import { getRandomBigInt } from "../utilities/0_bigint.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
+import { checkPassword } from "../utilities/1_password.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
@@ -11,7 +12,16 @@ import { MessageContainer } from "../tl/6_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
 import { SessionMemory } from "../session/session_memory.js";
+export const restartAuth = Symbol();
 export class Client extends ClientAbstract {
+    /**
+     * Constructs the client.
+     *
+     * @param session The session provider to use. Defaults to in-memory session.
+     * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
+     * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Default to empty string (unset).
+     * @param params Other parameters.
+     */
     constructor(session = new SessionMemory(), apiId = 0, apiHash = "", params) {
         super(params?.transportProvider);
         Object.defineProperty(this, "session", {
@@ -111,6 +121,12 @@ export class Client extends ClientAbstract {
         this.systemLangCode = params?.systemLangCode ?? DEFAULT_SYSTEM_LANG_CODE;
         this.systemVersion = params?.systemVersion ?? DEFAULT_SYSTEM_VERSION;
     }
+    /**
+     * Sets the DC and resets the auth key stored in the session provider
+     * if the stored DC was not the same as the `dc` parameter.
+     *
+     * @param dc The DC to change to.
+     */
     setDc(dc) {
         if (this.session.dc != dc) {
             this.session.dc = dc;
@@ -121,6 +137,11 @@ export class Client extends ClientAbstract {
         }
         super.setDc(dc);
     }
+    /**
+     * Loads the session if `setDc` was not called, initializes and connnects
+     * a `ClientPlain` to generate auth key if there was none, and connects the client.
+     * Before establishing the connection, the session is saved.
+     */
     async connect() {
         if (this.shouldLoadSession) {
             await this.session.load();
@@ -146,6 +167,23 @@ export class Client extends ClientAbstract {
         this.receiveLoop();
         this.pingLoop();
     }
+    /**
+     * Calls [initConnection](1) and authorizes the client with one of the following:
+     *
+     * - Bot token (`string`)
+     * - Exported authorization (`types.AuthExportedAuthorization`)
+     * - User authorization handlers (`AuthorizeUserParams`)
+     *
+     * if the current auth key doesn't throw AUTH_KEY_UNREGISTERED when calling [updates.getState](2).
+     *
+     * Notes:
+     * 1. Requires the `apiId` and `apiHash` paramters to be passed when constructing the client.
+     * 2. Reconnects the client to the appropriate DC in case of MIGRATE_X errors.
+     * 3. The parameters passed to the [initConnection][1] call can be configured with the last parameter of the constructor.
+     *
+     * [1]: https://core.telegram.org/method/initConnection
+     * [2]: https://core.telegram.org/method/updates.getState
+     */
     async authorize(params) {
         if (!this.apiId) {
             throw new Error("apiId not set");
@@ -175,12 +213,92 @@ export class Client extends ClientAbstract {
                 throw err;
             }
         }
+        let signedIn = false;
+        let phoneNumber = null;
         try {
             if (params instanceof types.AuthExportedAuthorization) {
                 await this.invoke(new functions.AuthImportAuthorization({ id: params.id, bytes: params.bytes }));
             }
             else if (typeof params == "object") {
-                throw new Error("Not implemented");
+                while (true) {
+                    if (signedIn) {
+                        break;
+                    }
+                    try {
+                        try {
+                            phoneNumber = typeof params.phone === "string" ? params.phone : await params.phone();
+                            const sentCode = await this.invoke(new functions.AuthSendCode({
+                                apiId: this.apiId,
+                                apiHash: this.apiHash,
+                                phoneNumber,
+                                settings: new types.CodeSettings(),
+                            }));
+                            if (sentCode instanceof types.AuthSentCode) {
+                                while (true) {
+                                    const phoneCode = typeof params.code === "string" ? params.code : await params.code();
+                                    try {
+                                        const auth = await this.invoke(new functions.AuthSignIn({ phoneNumber, phoneCode, phoneCodeHash: sentCode.phoneCodeHash }));
+                                        if (auth instanceof types.AuthAuthorizationSignUpRequired) {
+                                            throw new Error("Sign up not supported");
+                                        }
+                                        else {
+                                            signedIn = true;
+                                            break;
+                                        }
+                                    }
+                                    catch (err) {
+                                        if (err instanceof types.RPCError && err.errorMessage == "PHONE_CODE_INVALID") {
+                                            continue;
+                                        }
+                                        else {
+                                            throw err;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                throw new Error(`Handling ${sentCode.constructor.name} not implemented`);
+                            }
+                        }
+                        catch (err) {
+                            if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
+                                while (true) {
+                                    const ap = await this.invoke(new functions.AccountGetPassword());
+                                    if (ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
+                                        try {
+                                            const password = typeof params.password === "string" ? params.password : await params.password();
+                                            const input = await checkPassword(password, ap);
+                                            await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                                            break;
+                                        }
+                                        catch (err) {
+                                            if (err instanceof types.RPCError && err.errorMessage == "PASSWORD_HASH_INVALID") {
+                                                continue;
+                                            }
+                                            else {
+                                                throw err;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
+                                    }
+                                }
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        if (err == restartAuth) {
+                            continue;
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
             }
             else {
                 await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
@@ -195,6 +313,10 @@ export class Client extends ClientAbstract {
                         newDc += "-test";
                     }
                     await this.reconnect(newDc);
+                    if (typeof params === "object" && phoneNumber != null) {
+                        params = Object.assign({}, params);
+                        params.phone = phoneNumber;
+                    }
                     await this.authorize(params);
                 }
                 else {
@@ -318,6 +440,9 @@ export class Client extends ClientAbstract {
             return result;
         }
     }
+    /**
+     * Alias for `invoke` with its second parameter being `true`.
+     */
     send(function_) {
         return this.invoke(function_, true);
     }