@mtcute/core 0.17.0 → 0.18.0-rc.5

package/network/network-manager.js

@@ -0,0 +1,589 @@
+import { defaultReconnectionStrategy } from "@fuman/net";
+import { asNonNull, Deferred, composeMiddlewares } from "@fuman/utils";
+import { isTlRpcError, assertTypeIs } from "../utils/type-assertions.js";
+import { basic } from "./middlewares/default.js";
+import { MultiSessionConnection } from "./multi-session-connection.js";
+import { ServerSaltManager } from "./server-salt.js";
+import { MtArgumentError, MtcuteError, MtUnsupportedError } from "../types/errors.js";
+const defaultConnectionCountDelegate = (kind, dcId, isPremium) => {
+  switch (kind) {
+    case "main":
+      return 0;
+    case "upload":
+      return isPremium || dcId !== 2 && dcId !== 4 ? 8 : 4;
+    case "download":
+      return isPremium ? 8 : 2;
+    case "downloadSmall":
+      return 2;
+  }
+};
+class DcConnectionManager {
+  constructor(manager, dcId, _dcs, isPrimary = false) {
+    this.manager = manager;
+    this.dcId = dcId;
+    this._dcs = _dcs;
+    this.isPrimary = isPrimary;
+    this._log = this.manager._log.create("dc-manager");
+    this._log.prefix = `[DC ${dcId}] `;
+    const baseConnectionParams = () => ({
+      crypto: this.manager.params.crypto,
+      initConnection: this.manager._initConnectionParams,
+      transport: this.manager._transport,
+      dc: this._dcs.media,
+      testMode: this.manager.params.testMode,
+      reconnectionStrategy: this.manager._reconnectionStrategy,
+      layer: this.manager.params.layer,
+      disableUpdates: this.manager.params.disableUpdates,
+      readerMap: this.manager.params.readerMap,
+      writerMap: this.manager.params.writerMap,
+      usePfs: this.manager.params.usePfs,
+      isMainConnection: false,
+      isMainDcConnection: this.isPrimary,
+      inactivityTimeout: this.manager.params.inactivityTimeout ?? 6e4,
+      enableErrorReporting: this.manager.params.enableErrorReporting,
+      salts: this._salts,
+      platform: this.manager.params.platform,
+      pingInterval: this.manager.params.pingInterval ?? 6e4
+    });
+    const mainParams = baseConnectionParams();
+    mainParams.isMainConnection = true;
+    mainParams.dc = _dcs.main;
+    if (isPrimary) {
+      mainParams.inactivityTimeout = void 0;
+    }
+    let mainCount;
+    if (this.isPrimary) {
+      mainCount = this._mainCountOverride;
+      if (mainCount === 0) {
+        mainCount = this.manager.config.getCached()?.tmpSessions ?? 1;
+      }
+    } else {
+      mainCount = 1;
+    }
+    this.main = new MultiSessionConnection(mainParams, mainCount, this._log, "MAIN");
+    this.upload = new MultiSessionConnection(
+      baseConnectionParams(),
+      this.manager._connectionCount("upload", this.dcId, this.manager.params.isPremium),
+      this._log,
+      "UPLOAD"
+    );
+    this.download = new MultiSessionConnection(
+      baseConnectionParams(),
+      this.manager._connectionCount("download", this.dcId, this.manager.params.isPremium),
+      this._log,
+      "DOWNLOAD"
+    );
+    this.downloadSmall = new MultiSessionConnection(
+      baseConnectionParams(),
+      this.manager._connectionCount("downloadSmall", this.dcId, this.manager.params.isPremium),
+      this._log,
+      "DOWNLOAD_SMALL"
+    );
+    this._setupMulti("main");
+    this._setupMulti("upload");
+    this._setupMulti("download");
+    this._setupMulti("downloadSmall");
+  }
+  _salts = new ServerSaltManager();
+  _log;
+  /** Main connection pool */
+  main;
+  /** Upload connection pool */
+  upload;
+  /** Download connection pool */
+  download;
+  /** Download connection pool (for small files) */
+  downloadSmall;
+  get _mainCountOverride() {
+    return this.manager.params.connectionCount?.("main", this.dcId, this.manager.params.isPremium) ?? 0;
+  }
+  _setupMulti(kind) {
+    const connection = this[kind];
+    connection.onKeyChange.add(([idx, key]) => {
+      if (kind !== "main") {
+        this.manager._log.warn("got key-change from non-main connection, ignoring");
+        return;
+      }
+      this.manager._log.debug("key change for dc %d from connection %d", this.dcId, idx);
+      this.upload.setAuthKey(key);
+      this.download.setAuthKey(key);
+      this.downloadSmall.setAuthKey(key);
+      Promise.resolve(this.manager._storage.provider.authKeys.set(this.dcId, key)).then(() => {
+        this.upload.notifyKeyChange();
+        this.download.notifyKeyChange();
+        this.downloadSmall.notifyKeyChange();
+      }).catch((e) => {
+        this.manager._log.warn("failed to save auth key for dc %d: %e", this.dcId, e);
+        this.manager.params.emitError(e);
+      });
+    });
+    connection.onTmpKeyChange.add(([idx, key, expires]) => {
+      if (kind !== "main") {
+        this.manager._log.warn("got tmp-key-change from non-main connection, ignoring");
+        return;
+      }
+      this.manager._log.debug("temp key change for dc %d from connection %d", this.dcId, idx);
+      this.upload.setAuthKey(key, true);
+      this.download.setAuthKey(key, true);
+      this.downloadSmall.setAuthKey(key, true);
+      Promise.resolve(this.manager._storage.provider.authKeys.setTemp(this.dcId, idx, key, expires * 1e3)).then(() => {
+        this.upload.notifyKeyChange();
+        this.download.notifyKeyChange();
+        this.downloadSmall.notifyKeyChange();
+      }).catch((e) => {
+        this.manager._log.warn("failed to save temp auth key %d for dc %d: %e", idx, this.dcId, e);
+        this.manager.params.emitError(e);
+      });
+    });
+    connection.onFutureSalts.add((salts) => {
+      Promise.resolve(this.manager._storage.salts.store(this.dcId, salts)).catch(
+        (e) => this.manager.params.emitError(e)
+      );
+    });
+    connection.onAuthBegin.add(() => {
+      if (kind !== "main") {
+        this.manager._log.warn("got auth-begin from non-main connection, ignoring");
+        return;
+      }
+      this.upload.resetAuthKeys();
+      this.download.resetAuthKeys();
+      this.downloadSmall.resetAuthKeys();
+    });
+    connection.onRequestAuth.add(() => {
+      this.main.requestAuth();
+    });
+    connection.onRequestKeys.add((promise) => {
+      this.loadKeys(true).then(() => promise.resolve()).catch((e) => promise.reject(e));
+    });
+    connection.onError.add((err) => {
+      this.manager.params.emitError(err);
+    });
+  }
+  setIsPrimary(isPrimary) {
+    if (this.isPrimary === isPrimary) return;
+    this.isPrimary = isPrimary;
+    this.main.params.isMainDcConnection = isPrimary;
+    if (isPrimary) {
+      this.main.setInactivityTimeout(void 0);
+    } else {
+      this.main.setInactivityTimeout(this.manager.params.inactivityTimeout ?? 6e4);
+    }
+  }
+  setIsPremium(isPremium) {
+    this.upload.setCount(this.manager._connectionCount("upload", this.dcId, isPremium));
+    this.download.setCount(this.manager._connectionCount("download", this.dcId, isPremium));
+    this.downloadSmall.setCount(this.manager._connectionCount("downloadSmall", this.dcId, isPremium));
+  }
+  async loadKeys(forcePfs = false) {
+    const [permanent, salts] = await Promise.all([
+      this.manager._storage.provider.authKeys.get(this.dcId),
+      this.manager._storage.salts.fetch(this.dcId)
+    ]);
+    this.main.setAuthKey(permanent);
+    this.upload.setAuthKey(permanent);
+    this.download.setAuthKey(permanent);
+    this.downloadSmall.setAuthKey(permanent);
+    if (salts) {
+      this._salts.setFutureSalts(salts);
+    }
+    if (!permanent) {
+      return false;
+    }
+    if (this.manager.params.usePfs || forcePfs) {
+      const now = Date.now();
+      await Promise.all(
+        this.main._sessions.map(async (_, i) => {
+          const temp = await this.manager._storage.provider.authKeys.getTemp(this.dcId, i, now);
+          this.main.setAuthKey(temp, true, i);
+          if (i === 0) {
+            this.upload.setAuthKey(temp, true);
+            this.download.setAuthKey(temp, true);
+            this.downloadSmall.setAuthKey(temp, true);
+          }
+        })
+      );
+    }
+    return true;
+  }
+  setMainConnectionCount(count) {
+    if (this._mainCountOverride > 0) return;
+    this.main.setCount(count);
+  }
+  async destroy() {
+    await this.main.destroy();
+    await this.upload.destroy();
+    await this.download.destroy();
+    await this.downloadSmall.destroy();
+    this._salts.destroy();
+  }
+}
+class NetworkManager {
+  constructor(params, config) {
+    this.params = params;
+    this.config = config;
+    const deviceModel = `mtcute on ${params.platform.getDeviceModel()}`;
+    this._initConnectionParams = {
+      _: "initConnection",
+      deviceModel,
+      systemVersion: "1.0",
+      appVersion: "0.17.1",
+      systemLangCode: "en",
+      langPack: "",
+      // "langPacks are for official apps only"
+      langCode: "en",
+      ...params.initConnectionOptions ?? {},
+      apiId: params.apiId,
+      // eslint-disable-next-line
+      query: null
+    };
+    this._transport = params.transport;
+    this._reconnectionStrategy = params.reconnectionStrategy ?? defaultReconnectionStrategy;
+    this._connectionCount = params.connectionCount ?? defaultConnectionCountDelegate;
+    this._updateHandler = params.onUpdate;
+    this.call = this._composeCall(params.middlewares);
+    this._onConfigChanged = this._onConfigChanged.bind(this);
+    config.onUpdated.add(this._onConfigChanged);
+    this._log = params.log.create("network");
+    this._storage = params.storage;
+  }
+  _log;
+  _storage;
+  _initConnectionParams;
+  _transport;
+  _reconnectionStrategy;
+  _connectionCount;
+  _dcConnections = /* @__PURE__ */ new Map();
+  _primaryDc;
+  _primaryDcRecreationPromise;
+  _updateHandler;
+  async _findDcOptions(dcId) {
+    const main = await this.config.findOption({
+      dcId,
+      allowIpv6: this.params.useIpv6,
+      preferIpv6: this.params.useIpv6,
+      allowMedia: false,
+      cdn: false
+    });
+    const media = await this.config.findOption({
+      dcId,
+      allowIpv6: this.params.useIpv6,
+      preferIpv6: this.params.useIpv6,
+      allowMedia: true,
+      preferMedia: true,
+      cdn: false
+    });
+    if (!main || !media) {
+      throw new MtArgumentError(`Could not find DC ${dcId}`);
+    }
+    return { main, media };
+  }
+  _resetOnNetworkChange;
+  _switchPrimaryDc(dc) {
+    if (this._primaryDc && this._primaryDc !== dc) {
+      this._primaryDc.setIsPrimary(false);
+    }
+    this._primaryDc = dc;
+    dc.setIsPrimary(true);
+    this.params.onConnecting();
+    dc.main.onUsable.add(() => {
+      if (dc !== this._primaryDc) return;
+      this.params.onUsable();
+    });
+    dc.main.onWait.add(() => {
+      if (dc !== this._primaryDc) return;
+      this.params.onConnecting();
+    });
+    dc.main.onUpdate.add((update) => {
+      this._updateHandler(update, false);
+    });
+    return dc.loadKeys().then(() => dc.main.ensureConnected());
+  }
+  _dcCreationPromise = /* @__PURE__ */ new Map();
+  async _getOtherDc(dcId) {
+    if (!this._dcConnections.has(dcId)) {
+      if (this._dcCreationPromise.has(dcId)) {
+        this._log.debug("waiting for dc %d to be created", dcId);
+        await this._dcCreationPromise.get(dcId);
+        this._log.debug("dc %d was created", dcId);
+        return asNonNull(this._dcConnections.get(dcId));
+      }
+      const promise = new Deferred();
+      this._dcCreationPromise.set(dcId, promise.promise);
+      this._log.debug("creating new DC %d", dcId);
+      try {
+        const dcOptions = await this._findDcOptions(dcId);
+        const dc = new DcConnectionManager(this, dcId, dcOptions);
+        if (!await dc.loadKeys()) {
+          dc.main.requestAuth();
+        }
+        this._dcConnections.set(dcId, dc);
+        promise.resolve();
+        this._dcCreationPromise.delete(dcId);
+      } catch (e) {
+        promise.reject(e);
+        this._dcCreationPromise.delete(dcId);
+        return this._getOtherDc(dcId);
+      }
+    }
+    return this._dcConnections.get(dcId);
+  }
+  /**
+   * Perform initial connection to the default DC
+   *
+   * @param defaultDcs  Default DCs to connect to
+   */
+  async connect(defaultDcs) {
+    if (defaultDcs.main.id !== defaultDcs.media.id) {
+      throw new MtArgumentError("Default DCs must be the same");
+    }
+    if (this._dcConnections.has(defaultDcs.main.id)) {
+      throw new MtArgumentError("DC manager already exists");
+    }
+    this._resetOnNetworkChange = this.params.platform.onNetworkChanged?.(this.notifyNetworkChanged.bind(this));
+    const dc = new DcConnectionManager(this, defaultDcs.main.id, defaultDcs, true);
+    this._dcConnections.set(defaultDcs.main.id, dc);
+    await this._switchPrimaryDc(dc);
+  }
+  _pendingExports = /* @__PURE__ */ new Map();
+  async _exportAuthTo(manager) {
+    if (this._pendingExports.has(manager.dcId)) {
+      this._log.debug("waiting for auth export to dc %d", manager.dcId);
+      return this._pendingExports.get(manager.dcId);
+    }
+    this._log.debug("exporting auth to dc %d", manager.dcId);
+    const promise = new Deferred();
+    this._pendingExports.set(manager.dcId, promise.promise);
+    try {
+      const auth = await this.call({
+        _: "auth.exportAuthorization",
+        dcId: manager.dcId
+      });
+      if (isTlRpcError(auth)) {
+        throw new MtcuteError(`Failed to export (${auth.errorCode}: ${auth.errorMessage})`);
+      }
+      const res = await this.call(
+        {
+          _: "auth.importAuthorization",
+          id: auth.id,
+          bytes: auth.bytes
+        },
+        { manager }
+      );
+      if (isTlRpcError(res)) {
+        throw new MtcuteError(`Failed to import (${res.errorCode}: ${res.errorMessage})`);
+      }
+      assertTypeIs("auth.importAuthorization", res, "auth.authorization");
+      promise.resolve();
+      this._pendingExports.delete(manager.dcId);
+    } catch (e) {
+      this._log.warn("failed to export auth to dc %d: %s", manager.dcId, e);
+      promise.reject(e);
+      throw e;
+    }
+  }
+  setIsPremium(isPremium) {
+    this._log.debug("setting isPremium to %s", isPremium);
+    this.params.isPremium = isPremium;
+    for (const dc of this._dcConnections.values()) {
+      dc.setIsPremium(isPremium);
+    }
+  }
+  notifyLoggedIn(auth) {
+    if (auth._ === "auth.authorizationSignUpRequired") {
+      throw new MtUnsupportedError(
+        "Signup is no longer supported by Telegram for non-official clients. Please use your mobile device to sign up."
+      );
+    }
+    let user;
+    if (auth._ === "auth.authorization") {
+      if (auth.tmpSessions) {
+        this._primaryDc?.setMainConnectionCount(auth.tmpSessions);
+      }
+      user = auth.user;
+    } else {
+      if (auth.bot) {
+        this.config.update(true).catch((e) => this.params.emitError(e));
+      }
+      user = auth;
+    }
+    this.setIsPremium(user.premium);
+    if (auth._ === "auth.authorization" && this.params.disableUpdates) {
+      this.resetSessions();
+    }
+    return user;
+  }
+  notifyLoggedOut() {
+    this.setIsPremium(false);
+    this.resetSessions();
+  }
+  notifyNetworkChanged(connected) {
+    this._log.debug("network changed: %s", connected ? "connected" : "disconnected");
+    this.params.onNetworkChanged(connected);
+    for (const dc of this._dcConnections.values()) {
+      dc.main.notifyNetworkChanged(connected);
+      dc.upload.notifyNetworkChanged(connected);
+      dc.download.notifyNetworkChanged(connected);
+      dc.downloadSmall.notifyNetworkChanged(connected);
+    }
+  }
+  resetSessions() {
+    const dc = this._primaryDc;
+    if (!dc) return;
+    dc.main.resetSessions();
+    dc.upload.resetSessions();
+    dc.download.resetSessions();
+    dc.downloadSmall.resetSessions();
+  }
+  _onConfigChanged({ current }) {
+    if (current?.tmpSessions) {
+      this._primaryDc?.setMainConnectionCount(current.tmpSessions);
+    }
+  }
+  async changePrimaryDc(newDc) {
+    if (newDc === this._primaryDc?.dcId) return;
+    const options = await this._findDcOptions(newDc);
+    if (!this._dcConnections.has(newDc)) {
+      this._dcConnections.set(newDc, new DcConnectionManager(this, newDc, options, true));
+    }
+    await this._storage.dcs.store(options);
+    await this._switchPrimaryDc(this._dcConnections.get(newDc));
+  }
+  call;
+  _composeCall = (middlewares) => {
+    if (!middlewares) {
+      middlewares = basic();
+    }
+    if (!middlewares.length) {
+      return this._call;
+    }
+    const final = async (ctx) => {
+      return this._call(ctx.request, ctx.params);
+    };
+    const composed = composeMiddlewares(middlewares, final);
+    return async (message, params) => composed({
+      request: message,
+      manager: this,
+      params
+    });
+  };
+  _call = async (message, params) => {
+    if (!this._primaryDc) {
+      if (this._primaryDcRecreationPromise) {
+        await this._primaryDcRecreationPromise.promise;
+      } else {
+        throw new MtcuteError("Not connected to any DC");
+      }
+    }
+    const kind = params?.kind ?? "main";
+    let manager;
+    if (params?.manager) {
+      manager = params.manager;
+    } else if (params?.dcId && params.dcId !== this._primaryDc.dcId) {
+      manager = await this._getOtherDc(params.dcId);
+    } else {
+      manager = this._primaryDc;
+    }
+    let multi = manager[kind];
+    let res = await multi.sendRpc(message, params?.timeout, params?.abortSignal, params?.chainId);
+    if (!isTlRpcError(res)) {
+      return res;
+    }
+    const err = res.errorMessage;
+    if (manager === this._primaryDc) {
+      if (err.startsWith("PHONE_MIGRATE_") || err.startsWith("NETWORK_MIGRATE_") || err.startsWith("USER_MIGRATE_")) {
+        const newDc = Number(err.slice(err.lastIndexOf("_") + 1));
+        if (Number.isNaN(newDc)) {
+          this._log.warn("invalid migrate error received: %s, ignoring", err);
+          return res;
+        }
+        if (params?.localMigrate) {
+          manager = await this._getOtherDc(newDc);
+        } else {
+          this._log.info("received %s, migrating to dc %d", err, newDc);
+          await this.changePrimaryDc(newDc);
+          manager = this._primaryDc;
+        }
+        multi = manager[kind];
+        res = await multi.sendRpc(message, params?.timeout, params?.abortSignal, params?.chainId);
+      }
+    } else if (err === "AUTH_KEY_UNREGISTERED") {
+      this._log.warn("exported auth key error, trying re-exporting..");
+      await this._exportAuthTo(manager);
+      res = await multi.sendRpc(message, params?.timeout, params?.abortSignal, params?.chainId);
+    }
+    return res;
+  };
+  async changeTransport(transport) {
+    for (const dc of this._dcConnections.values()) {
+      await dc.main.changeTransport(transport);
+      await dc.upload.changeTransport(transport);
+      await dc.download.changeTransport(transport);
+      await dc.downloadSmall.changeTransport(transport);
+    }
+  }
+  getPoolSize(kind, dcId) {
+    const dc = dcId ? this._dcConnections.get(dcId) : this._primaryDc;
+    if (!dc) {
+      if (!this._primaryDc) {
+        throw new MtcuteError("Not connected to any DC");
+      }
+      return this._connectionCount(kind, dcId ?? this._primaryDc.dcId, this.params.isPremium);
+    }
+    return dc[kind].getPoolSize();
+  }
+  getPrimaryDcId() {
+    if (!this._primaryDc) throw new MtcuteError("Not connected to any DC");
+    return this._primaryDc.dcId;
+  }
+  async destroy() {
+    for (const dc of this._dcConnections.values()) {
+      await dc.destroy();
+    }
+    this._dcConnections.clear();
+    this.config.onUpdated.remove(this._onConfigChanged);
+    this._resetOnNetworkChange?.();
+  }
+  getMtprotoMessageId() {
+    return this._primaryDc.main._sessions[0].getMessageId();
+  }
+  async recreateDc(dcId) {
+    this._log.debug("recreating dc %d", dcId);
+    const existing = this._dcConnections.get(dcId);
+    if (existing) {
+      await existing.destroy();
+    }
+    this._dcConnections.delete(dcId);
+    if (dcId === this._primaryDc?.dcId) {
+      const oldPrimaryDc = this._primaryDc;
+      this._primaryDc = void 0;
+      this._primaryDcRecreationPromise = new Deferred();
+      try {
+        const newDefaultDcs = {
+          main: asNonNull(await this.config.findOption({
+            dcId,
+            allowIpv6: this.params.useIpv6
+          })),
+          media: asNonNull(await this.config.findOption({
+            dcId,
+            allowIpv6: this.params.useIpv6,
+            allowMedia: true,
+            preferMedia: true
+          }))
+        };
+        await this._storage.dcs.store(newDefaultDcs);
+        await this.connect(newDefaultDcs);
+        this._primaryDcRecreationPromise.resolve();
+        this._primaryDcRecreationPromise = void 0;
+      } catch (e) {
+        this._primaryDc = oldPrimaryDc;
+        this._primaryDcRecreationPromise?.resolve();
+        this._primaryDcRecreationPromise = void 0;
+        throw e;
+      }
+    }
+  }
+}
+export {
+  DcConnectionManager,
+  NetworkManager
+};