@mtcute/core 0.17.0 → 0.18.0-rc.5

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.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.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.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
+};

package/highlevel/methods/auth/start.cjs

@@ -0,0 +1,154 @@
+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 tl = require("@mtcute/tl");
+const errors = require("../../../types/errors.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const getMe = require("../users/get-me.cjs");
+const checkPassword = require("./check-password.cjs");
+const resendCode = require("./resend-code.cjs");
+const sendCode = require("./send-code.cjs");
+const signInBot = require("./sign-in-bot.cjs");
+const signInQr = require("./sign-in-qr.cjs");
+const signIn = require("./sign-in.cjs");
+async function start(client, params) {
+  if (params.session) {
+    await client.importSession(params.session, params.sessionForce);
+  }
+  const { abortSignal } = params;
+  let has2fa = false;
+  let sentCode;
+  let phone = null;
+  try {
+    const me = await getMe.getMe(client);
+    client.log.info("Logged in as %s (ID: %s, username: %s, bot: %s)", me.displayName, me.id, me.username, me.isBot);
+    await client.notifyLoggedIn(me.raw);
+    return me;
+  } catch (e) {
+    if (tl.tl.RpcError.is(e)) {
+      if (e.text === "SESSION_PASSWORD_NEEDED") has2fa = true;
+      else if (e.text !== "AUTH_KEY_UNREGISTERED") throw e;
+    } else {
+      throw e;
+    }
+  }
+  if (!has2fa && !params.qrCodeHandler) {
+    if (!params.phone && !params.botToken) {
+      throw new errors.MtArgumentError("Neither phone nor bot token were provided");
+    }
+    phone = params.phone ? await miscUtils.resolveMaybeDynamic(params.phone) : null;
+    if (phone) {
+      phone = miscUtils.normalizePhoneNumber(phone);
+      if (!params.code) {
+        throw new errors.MtArgumentError("You must pass `code` to use `phone`");
+      }
+    } else {
+      const botToken = params.botToken ? await miscUtils.resolveMaybeDynamic(params.botToken) : null;
+      if (!botToken) {
+        throw new errors.MtArgumentError("Either bot token or phone number must be provided");
+      }
+      return signInBot.signInBot(client, botToken);
+    }
+    try {
+      sentCode = await sendCode.sendCode(client, {
+        phone,
+        futureAuthTokens: params.futureAuthTokens,
+        codeSettings: params.codeSettings,
+        abortSignal
+      });
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED")) {
+        has2fa = true;
+      } else {
+        throw e;
+      }
+    }
+  }
+  if (sentCode) {
+    if (params.forceSms && (sentCode.type === "app" || sentCode.type === "email")) {
+      sentCode = await resendCode.resendCode(client, {
+        phone,
+        phoneCodeHash: sentCode.phoneCodeHash,
+        abortSignal
+      });
+    }
+    if (params.codeSentCallback) {
+      await params.codeSentCallback(sentCode);
+    } else {
+      if (sentCode.type === "email_required") {
+        throw new errors.MtcuteError("Email login setup is required to sign in");
+      }
+      console.log(`The confirmation code has been sent via ${sentCode.type}.`);
+    }
+    for (; ; ) {
+      const code = await miscUtils.resolveMaybeDynamic(params.code);
+      if (!code) throw new tl.tl.RpcError(400, "PHONE_CODE_EMPTY");
+      try {
+        return await signIn.signIn(client, {
+          phone,
+          phoneCodeHash: sentCode.phoneCodeHash,
+          phoneCode: code,
+          abortSignal
+        });
+      } catch (e) {
+        if (!tl.tl.RpcError.is(e)) throw e;
+        if (e.is("SESSION_PASSWORD_NEEDED")) {
+          has2fa = true;
+          break;
+        } else if (e.is("PHONE_CODE_EMPTY") || e.is("PHONE_CODE_EXPIRED") || e.is("PHONE_CODE_INVALID") || e.is("PHONE_CODE_HASH_EMPTY")) {
+          if (typeof params.code !== "function") {
+            throw new errors.MtArgumentError("Provided code was invalid");
+          }
+          if (params.invalidCodeCallback) {
+            await params.invalidCodeCallback("code");
+          } else {
+            console.log("Invalid code. Please try again");
+          }
+          continue;
+        } else {
+          throw e;
+        }
+      }
+      break;
+    }
+  }
+  if (has2fa) {
+    if (!params.password) {
+      throw new errors.MtArgumentError("2FA is enabled, but `password` was not provided.");
+    }
+    for (; ; ) {
+      const password = await miscUtils.resolveMaybeDynamic(params.password);
+      try {
+        return await checkPassword.checkPassword(client, password);
+      } catch (e) {
+        if (typeof params.password !== "function") {
+          throw new errors.MtArgumentError("Provided password was invalid");
+        }
+        if (tl.tl.RpcError.is(e, "PASSWORD_HASH_INVALID")) {
+          if (params.invalidCodeCallback) {
+            await params.invalidCodeCallback("password");
+          } else {
+            console.log("Invalid password. Please try again");
+          }
+          continue;
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  if (params.qrCodeHandler) {
+    return signInQr.signInQr(client, {
+      onUrlUpdated: params.qrCodeHandler,
+      password: params.password,
+      invalidPasswordCallback: params.invalidCodeCallback ? () => params.invalidCodeCallback("password") : void 0,
+      abortSignal
+    });
+  }
+  throw new errors.MtArgumentError("Failed to log in with provided credentials");
+}
+exports.start = start;

package/highlevel/methods/auth/start.d.ts

@@ -1,10 +1,10 @@
-import { tl } from '@mtcute/tl';
 import { MaybePromise } from '../../../types/utils.js';
 import { ITelegramClient } from '../../client.types.js';
 import { SentCode } from '../../types/auth/sent-code.js';
 import { User } from '../../types/peers/user.js';
 import { MaybeDynamic } from '../../types/utils.js';
-import { StringSessionData } from '../../utils/string-session.js';
+import { InputStringSessionData } from '../../utils/string-session.js';
+import { tl } from '@mtcute/tl';
 /**
  * Start the client in an interactive and declarative manner,
  * by providing callbacks for authorization details.
@@ -27,7 +27,7 @@ export declare function start(client: ITelegramClient, params: {
      * Note that passed session will be ignored in case storage already
      * contains authorization.
      */
-    session?: string | StringSessionData;
+    session?: string | InputStringSessionData;
     /**
      * Whether to overwrite existing session.
      */