@mtcute/core 0.17.1 → 0.18.0

package/highlevel/methods/auth/send-code.cjs

@@ -0,0 +1,31 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const sentCode = require("../../types/auth/sent-code.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+async function sendCode(client, params) {
+  const phone = miscUtils.normalizePhoneNumber(params.phone);
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call(
+    {
+      _: "auth.sendCode",
+      phoneNumber: phone,
+      apiId: id,
+      apiHash: hash,
+      settings: {
+        _: "codeSettings",
+        logoutTokens: params.futureAuthTokens,
+        ...params.codeSettings
+      }
+    },
+    { abortSignal: params.abortSignal }
+  );
+  typeAssertions.assertTypeIs("sendCode", res, "auth.sentCode");
+  return new sentCode.SentCode(res);
+}
+exports.sendCode = sendCode;

package/highlevel/methods/auth/send-code.d.cts

@@ -0,0 +1,18 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { SentCode } from '../../types/auth/sent-code.js';
+/**
+ * Send the confirmation code to the given phone number
+ *
+ * @returns  An object containing information about the sent confirmation code
+ */
+export declare function sendCode(client: ITelegramClient, params: {
+    /** Phone number in international format */
+    phone: string;
+    /** Saved future auth tokens, if any */
+    futureAuthTokens?: Uint8Array[];
+    /** Additional code settings to pass to the server */
+    codeSettings?: Omit<tl.RawCodeSettings, '_' | 'logoutTokens'>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<SentCode>;

package/highlevel/methods/auth/send-code.js

@@ -0,0 +1,26 @@
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { SentCode as SentCode$1 } from "../../types/auth/sent-code.js";
+import { normalizePhoneNumber } from "../../utils/misc-utils.js";
+async function sendCode(client, params) {
+  const phone = normalizePhoneNumber(params.phone);
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call(
+    {
+      _: "auth.sendCode",
+      phoneNumber: phone,
+      apiId: id,
+      apiHash: hash,
+      settings: {
+        _: "codeSettings",
+        logoutTokens: params.futureAuthTokens,
+        ...params.codeSettings
+      }
+    },
+    { abortSignal: params.abortSignal }
+  );
+  assertTypeIs("sendCode", res, "auth.sentCode");
+  return new SentCode$1(res);
+}
+export {
+  sendCode
+};

package/highlevel/methods/auth/send-recovery-code.cjs

@@ -0,0 +1,13 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function sendRecoveryCode(client) {
+  return client.call({
+    _: "auth.requestPasswordRecovery"
+  }).then((res) => res.emailPattern);
+}
+exports.sendRecoveryCode = sendRecoveryCode;

package/highlevel/methods/auth/send-recovery-code.d.cts

@@ -0,0 +1,7 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Send a code to email needed to recover your password
+ *
+ * @returns  String containing email pattern to which the recovery code was sent
+ */
+export declare function sendRecoveryCode(client: ITelegramClient): Promise<string>;

package/highlevel/methods/auth/send-recovery-code.js

@@ -0,0 +1,8 @@
+function sendRecoveryCode(client) {
+  return client.call({
+    _: "auth.requestPasswordRecovery"
+  }).then((res) => res.emailPattern);
+}
+export {
+  sendRecoveryCode
+};

package/highlevel/methods/auth/sign-in-bot.cjs

@@ -0,0 +1,20 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("./utils.cjs");
+async function signInBot(client, token) {
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call({
+    _: "auth.importBotAuthorization",
+    flags: 0,
+    apiId: id,
+    apiHash: hash,
+    botAuthToken: token
+  });
+  return utils._onAuthorization(client, res);
+}
+exports.signInBot = signInBot;

package/highlevel/methods/auth/sign-in-bot.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/peers/user.js';
+/**
+ * Authorize a bot using its token issued by [@BotFather](//t.me/BotFather)
+ *
+ * @param token  Bot token issued by BotFather
+ * @returns  Bot's {@link User} object
+ * @throws BadRequestError  In case the bot token is invalid
+ */
+export declare function signInBot(client: ITelegramClient, token: string): Promise<User>;

package/highlevel/methods/auth/sign-in-bot.js

@@ -0,0 +1,15 @@
+import { _onAuthorization } from "./utils.js";
+async function signInBot(client, token) {
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call({
+    _: "auth.importBotAuthorization",
+    flags: 0,
+    apiId: id,
+    apiHash: hash,
+    botAuthToken: token
+  });
+  return _onAuthorization(client, res);
+}
+export {
+  signInBot
+};

package/highlevel/methods/auth/sign-in-qr.cjs

@@ -0,0 +1,119 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const tl = require("@mtcute/tl");
+const miscUtils$1 = require("../../../utils/misc-utils.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const checkPassword = require("./check-password.cjs");
+const user = require("../../types/peers/user.cjs");
+async function signInQr(client, params) {
+  const { onUrlUpdated, abortSignal, onQrScanned } = params;
+  let waiter;
+  const onUpdate = ({ update }) => {
+    if (update._ === "updateLoginToken") {
+      onQrScanned?.();
+      waiter?.resolve();
+      client.onRawUpdate.remove(onUpdate);
+    }
+  };
+  client.onRawUpdate.add(onUpdate);
+  abortSignal?.addEventListener("abort", () => {
+    client.onRawUpdate.remove(onUpdate);
+    waiter?.reject(abortSignal.reason);
+  });
+  async function handle2fa(input) {
+    const isDynamic = typeof input === "function";
+    while (true) {
+      const password = await miscUtils.resolveMaybeDynamic(input);
+      try {
+        return await checkPassword.checkPassword(client, password);
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "PASSWORD_HASH_INVALID")) {
+          if (!isDynamic) {
+            throw e;
+          }
+          if (params.invalidPasswordCallback) {
+            await params.invalidPasswordCallback?.();
+          } else {
+            console.log("Invalid password. Please try again");
+          }
+          continue;
+        }
+        throw e;
+      }
+    }
+  }
+  try {
+    const { id, hash } = await client.getApiCrenetials();
+    loop: while (true) {
+      let res;
+      try {
+        res = await client.call(
+          {
+            _: "auth.exportLoginToken",
+            apiId: id,
+            apiHash: hash,
+            exceptIds: []
+          },
+          { abortSignal }
+        );
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+          return await handle2fa(params.password);
+        }
+        throw e;
+      }
+      switch (res._) {
+        case "auth.loginToken":
+          onUrlUpdated(
+            `tg://login?token=${utils.base64.encode(res.token, true)}`,
+            new Date(res.expires * 1e3)
+          );
+          waiter = new utils.Deferred();
+          await Promise.race([waiter, miscUtils$1.sleepWithAbort(res.expires * 1e3 - Date.now(), client.stopSignal)]);
+          break;
+        case "auth.loginTokenMigrateTo": {
+          await client.changePrimaryDc(res.dcId);
+          let res2;
+          try {
+            res2 = await client.call(
+              {
+                _: "auth.importLoginToken",
+                token: res.token
+              },
+              { abortSignal }
+            );
+          } catch (e) {
+            if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+              return await handle2fa(params.password);
+            }
+            throw e;
+          }
+          typeAssertions.assertTypeIs("auth.importLoginToken", res2, "auth.loginTokenSuccess");
+          break loop;
+        }
+        case "auth.loginTokenSuccess":
+          break loop;
+      }
+    }
+    const [self] = await client.call(
+      {
+        _: "users.getUsers",
+        id: [{ _: "inputUserSelf" }]
+      },
+      { abortSignal }
+    );
+    typeAssertions.assertTypeIs("users.getUsers", self, "user");
+    await client.notifyLoggedIn(self);
+    return new user.User(self);
+  } finally {
+    client.onRawUpdate.remove(onUpdate);
+  }
+}
+exports.signInQr = signInQr;

package/highlevel/methods/auth/sign-in-qr.d.cts

@@ -0,0 +1,33 @@
+import { MaybePromise } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { MaybeDynamic, User } from '../../types/index.js';
+/**
+ * Execute the [QR login flow](https://core.telegram.org/api/qr-login).
+ *
+ * This method will resolve once the authorization is complete,
+ * returning the authorized user.
+ */
+export declare function signInQr(client: ITelegramClient, params: {
+    /**
+     * Function that will be called whenever the login URL is changed.
+     *
+     * The app is expected to display `url` as a QR code to the user
+     */
+    onUrlUpdated: (url: string, expires: Date) => void;
+    /**
+     * Function that will be called when the user has scanned the QR code
+     * (i.e. when `updateLoginToken` is received), and the library is finalizing the auth
+     */
+    onQrScanned?: () => void;
+    /** Password for 2FA */
+    password?: MaybeDynamic<string>;
+    /**
+     * Function that will be called after the server has rejected the password.
+     *
+     * Note that in case {@link password} is not a function,
+     * this callback will never be called, and an error will be thrown instead.
+     */
+    invalidPasswordCallback?: () => MaybePromise<void>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<User>;

package/highlevel/methods/auth/sign-in-qr.js

@@ -0,0 +1,114 @@
+import { base64, Deferred } from "@fuman/utils";
+import { tl } from "@mtcute/tl";
+import { sleepWithAbort } from "../../../utils/misc-utils.js";
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { resolveMaybeDynamic } from "../../utils/misc-utils.js";
+import { checkPassword } from "./check-password.js";
+import { User as User$2 } from "../../types/peers/user.js";
+async function signInQr(client, params) {
+  const { onUrlUpdated, abortSignal, onQrScanned } = params;
+  let waiter;
+  const onUpdate = ({ update }) => {
+    if (update._ === "updateLoginToken") {
+      onQrScanned?.();
+      waiter?.resolve();
+      client.onRawUpdate.remove(onUpdate);
+    }
+  };
+  client.onRawUpdate.add(onUpdate);
+  abortSignal?.addEventListener("abort", () => {
+    client.onRawUpdate.remove(onUpdate);
+    waiter?.reject(abortSignal.reason);
+  });
+  async function handle2fa(input) {
+    const isDynamic = typeof input === "function";
+    while (true) {
+      const password = await resolveMaybeDynamic(input);
+      try {
+        return await checkPassword(client, password);
+      } catch (e) {
+        if (tl.RpcError.is(e, "PASSWORD_HASH_INVALID")) {
+          if (!isDynamic) {
+            throw e;
+          }
+          if (params.invalidPasswordCallback) {
+            await params.invalidPasswordCallback?.();
+          } else {
+            console.log("Invalid password. Please try again");
+          }
+          continue;
+        }
+        throw e;
+      }
+    }
+  }
+  try {
+    const { id, hash } = await client.getApiCrenetials();
+    loop: while (true) {
+      let res;
+      try {
+        res = await client.call(
+          {
+            _: "auth.exportLoginToken",
+            apiId: id,
+            apiHash: hash,
+            exceptIds: []
+          },
+          { abortSignal }
+        );
+      } catch (e) {
+        if (tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+          return await handle2fa(params.password);
+        }
+        throw e;
+      }
+      switch (res._) {
+        case "auth.loginToken":
+          onUrlUpdated(
+            `tg://login?token=${base64.encode(res.token, true)}`,
+            new Date(res.expires * 1e3)
+          );
+          waiter = new Deferred();
+          await Promise.race([waiter, sleepWithAbort(res.expires * 1e3 - Date.now(), client.stopSignal)]);
+          break;
+        case "auth.loginTokenMigrateTo": {
+          await client.changePrimaryDc(res.dcId);
+          let res2;
+          try {
+            res2 = await client.call(
+              {
+                _: "auth.importLoginToken",
+                token: res.token
+              },
+              { abortSignal }
+            );
+          } catch (e) {
+            if (tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+              return await handle2fa(params.password);
+            }
+            throw e;
+          }
+          assertTypeIs("auth.importLoginToken", res2, "auth.loginTokenSuccess");
+          break loop;
+        }
+        case "auth.loginTokenSuccess":
+          break loop;
+      }
+    }
+    const [self] = await client.call(
+      {
+        _: "users.getUsers",
+        id: [{ _: "inputUserSelf" }]
+      },
+      { abortSignal }
+    );
+    assertTypeIs("users.getUsers", self, "user");
+    await client.notifyLoggedIn(self);
+    return new User$2(self);
+  } finally {
+    client.onRawUpdate.remove(onUpdate);
+  }
+}
+export {
+  signInQr
+};

package/highlevel/methods/auth/sign-in.cjs

@@ -0,0 +1,23 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const miscUtils = require("../../utils/misc-utils.cjs");
+const utils = require("./utils.cjs");
+async function signIn(client, params) {
+  const { phone, phoneCodeHash, phoneCode, abortSignal } = params;
+  const res = await client.call(
+    {
+      _: "auth.signIn",
+      phoneNumber: miscUtils.normalizePhoneNumber(phone),
+      phoneCodeHash,
+      phoneCode
+    },
+    { abortSignal }
+  );
+  return utils._onAuthorization(client, res);
+}
+exports.signIn = signIn;

package/highlevel/methods/auth/sign-in.d.cts

@@ -0,0 +1,19 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/peers/user.js';
+/**
+ * Authorize a user in Telegram with a valid confirmation code.
+ *
+ * @returns  If the code was valid and authorization succeeded, the {@link User} is returned.
+ * @throws  BadRequestError  In case the arguments are invalid
+ * @throws  SessionPasswordNeededError  In case a password is needed to sign in
+ */
+export declare function signIn(client: ITelegramClient, params: {
+    /** Phone number in international format */
+    phone: string;
+    /** Code identifier from {@link sendCode} */
+    phoneCodeHash: string;
+    /** The confirmation code that was received */
+    phoneCode: string;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<User>;

package/highlevel/methods/auth/sign-in.js

@@ -0,0 +1,18 @@
+import { normalizePhoneNumber } from "../../utils/misc-utils.js";
+import { _onAuthorization } from "./utils.js";
+async function signIn(client, params) {
+  const { phone, phoneCodeHash, phoneCode, abortSignal } = params;
+  const res = await client.call(
+    {
+      _: "auth.signIn",
+      phoneNumber: normalizePhoneNumber(phone),
+      phoneCodeHash,
+      phoneCode
+    },
+    { abortSignal }
+  );
+  return _onAuthorization(client, res);
+}
+export {
+  signIn
+};

package/highlevel/methods/auth/start-test.cjs

@@ -0,0 +1,54 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../../types/errors.cjs");
+const logOut = require("./log-out.cjs");
+const start = require("./start.cjs");
+async function startTest(client, params) {
+  if (!params) params = {};
+  if (params.logout) {
+    try {
+      await logOut.logOut(client);
+    } catch {
+    }
+  }
+  const availableDcs = await client.call({
+    _: "help.getConfig"
+  }).then((res) => res.dcOptions);
+  let phone = params.phone;
+  if (phone) {
+    if (!phone.match(/^99966\d{5}/)) {
+      throw new errors.MtArgumentError(`${phone} is an invalid test phone number`);
+    }
+    const id = Number.parseInt(phone[5]);
+    if (!availableDcs.find((dc) => dc.id === id)) {
+      throw new errors.MtArgumentError(`${phone} has invalid DC ID (${id})`);
+    }
+  } else {
+    let dcId = await client.getPrimaryDcId();
+    if (params.dcId) {
+      if (!availableDcs.find((dc) => dc.id === params.dcId)) {
+        throw new errors.MtArgumentError(`DC ID is invalid (${dcId})`);
+      }
+      dcId = params.dcId;
+    }
+    let numbers = Math.floor(Math.random() * 9999).toString();
+    while (numbers.length !== 4) numbers += "0";
+    phone = `99966${dcId}${numbers}`;
+  }
+  let code = "";
+  return start.start(client, {
+    phone,
+    code: () => code,
+    codeSentCallback: (sent) => {
+      for (let i = 0; i < sent.length; i++) {
+        code += phone[5];
+      }
+    }
+  });
+}
+exports.startTest = startTest;

package/highlevel/methods/auth/start-test.d.cts

@@ -0,0 +1,30 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Utility function to quickly authorize on test DC
+ * using a [Test phone number](https://core.telegram.org/api/auth#test-phone-numbers),
+ * which is randomly generated by default.
+ *
+ * > **Note**: Using this method assumes that you
+ * > are using a test DC in `primaryDc` parameter.
+ *
+ * @param params  Additional parameters
+ */
+export declare function startTest(client: ITelegramClient, params?: {
+    /**
+     * Whether to log out if current session is logged in.
+     *
+     * @default  false.
+     */
+    logout?: boolean;
+    /**
+     * Override phone number. Must be a valid Test phone number.
+     *
+     * By default is randomly generated.
+     */
+    phone?: string;
+    /**
+     * Override user's DC. Must be a valid test DC.
+     */
+    dcId?: number;
+}): Promise<User>;

package/highlevel/methods/auth/start-test.js

@@ -0,0 +1,49 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { logOut } from "./log-out.js";
+import { start } from "./start.js";
+async function startTest(client, params) {
+  if (!params) params = {};
+  if (params.logout) {
+    try {
+      await logOut(client);
+    } catch {
+    }
+  }
+  const availableDcs = await client.call({
+    _: "help.getConfig"
+  }).then((res) => res.dcOptions);
+  let phone = params.phone;
+  if (phone) {
+    if (!phone.match(/^99966\d{5}/)) {
+      throw new MtArgumentError(`${phone} is an invalid test phone number`);
+    }
+    const id = Number.parseInt(phone[5]);
+    if (!availableDcs.find((dc) => dc.id === id)) {
+      throw new MtArgumentError(`${phone} has invalid DC ID (${id})`);
+    }
+  } else {
+    let dcId = await client.getPrimaryDcId();
+    if (params.dcId) {
+      if (!availableDcs.find((dc) => dc.id === params.dcId)) {
+        throw new MtArgumentError(`DC ID is invalid (${dcId})`);
+      }
+      dcId = params.dcId;
+    }
+    let numbers = Math.floor(Math.random() * 9999).toString();
+    while (numbers.length !== 4) numbers += "0";
+    phone = `99966${dcId}${numbers}`;
+  }
+  let code = "";
+  return start(client, {
+    phone,
+    code: () => code,
+    codeSentCallback: (sent) => {
+      for (let i = 0; i < sent.length; i++) {
+        code += phone[5];
+      }
+    }
+  });
+}
+export {
+  startTest
+};