@mtcute/core 0.18.0-rc.5 → 0.19.0

package/network/network-manager.d.cts

@@ -0,0 +1,256 @@
+import { Middleware, Deferred } from '@fuman/utils';
+import { mtp, tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { default as Long } from 'long';
+import { StorageManager } from '../storage/storage.js';
+import { ICorePlatform } from '../types/platform.js';
+import { DcOptions, ICryptoProvider, Logger } from '../utils/index.js';
+import { ConfigManager } from './config-manager.js';
+import { TelegramTransport } from './transports/abstract.js';
+import { ReconnectionStrategy } from '@fuman/net';
+import { MultiSessionConnection } from './multi-session-connection.js';
+export type ConnectionKind = 'main' | 'upload' | 'download' | 'downloadSmall';
+/**
+ * Params passed into {@link NetworkManager} by {@link TelegramClient}.
+ * This type is intended for internal usage only.
+ */
+export interface NetworkManagerParams {
+    storage: StorageManager;
+    crypto: ICryptoProvider;
+    log: Logger;
+    platform: ICorePlatform;
+    enableErrorReporting: boolean;
+    apiId: number;
+    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>;
+    transport: TelegramTransport;
+    reconnectionStrategy?: ReconnectionStrategy;
+    disableUpdates?: boolean;
+    testMode: boolean;
+    layer: number;
+    useIpv6: boolean;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+    isPremium: boolean;
+    emitError: (err: Error) => void;
+    onUpdate: (upd: tl.TypeUpdates) => void;
+    onUsable: () => void;
+    onConnecting: () => void;
+    onNetworkChanged: (connected: boolean) => void;
+    stopSignal: AbortSignal;
+}
+export type ConnectionCountDelegate = (kind: ConnectionKind, dcId: number, isPremium: boolean) => number;
+/**
+ * Additional params passed into {@link NetworkManager} by the user
+ * that customize the behavior of the manager
+ */
+export interface NetworkManagerExtraParams {
+    /**
+     * Whether to use PFS (Perfect Forward Secrecy) for all connections.
+     * This is disabled by default
+     */
+    usePfs?: boolean;
+    /**
+     * Connection count for each connection kind.
+     * The function should be pure to avoid unexpected behavior.
+     *
+     * Defaults to TDLib logic:
+     *   - main: 0 (which stands for "handle internally, based on tmp_sessions value")
+     *   - upload: if premium or dc id is other than 2 or 4, then 8, otherwise 4
+     *   - download: if premium then 8, otherwise 2
+     *   - downloadSmall: 2
+     *
+     * Non-zero value for `main` is **for advanced users only**
+     * as it may lead to unexpected behavior, and is generally not recommended
+     * because of unnecessary extra load on both the server and the client as well as
+     * increased possibility of encountering AUTH_KEY_DUPLICATED errors.
+     */
+    connectionCount?: ConnectionCountDelegate;
+    /**
+     * Idle timeout for non-main connections, in ms
+     *
+     * @default  60000 (60 seconds).
+     */
+    inactivityTimeout?: number;
+    /**
+     * List of middlewares to use for the network manager
+     *
+     * > **Note**: these middlewares apply to **outgoing requests only**.
+     * > If you need to handle incoming updates, use a {@link Dispatcher} instead.
+     */
+    middlewares?: Middleware<RpcCallMiddlewareContext, unknown>[];
+    /**
+     * Ping interval in milliseconds.
+     *
+     * @default  60000 (1 minute)
+     */
+    pingInterval?: number;
+}
+/** Options that can be customized when making an RPC call */
+export interface RpcCallOptions {
+    /**
+     * If the call results in a `FLOOD_WAIT_X` error,
+     * the maximum amount of time to wait before retrying.
+     *
+     * If set to `0`, the call will not be retried.
+     *
+     * Only applies when the flood waiter middleware is enabled.
+     */
+    floodSleepThreshold?: number;
+    /**
+     * If the call results in an internal server error or a flood wait,
+     * the maximum amount of times to retry the call.
+     *
+     * Only applies when the flood waiter middleware and/or
+     * internal errors handler middleware is enabled.
+     */
+    maxRetryCount?: number;
+    /**
+     * Timeout for the call, in milliseconds.
+     *
+     * @default Infinity
+     */
+    timeout?: number;
+    /**
+     * **ADVANCED**
+     *
+     * Kind of connection to use for this call.
+     *
+     * @default 'main'
+     */
+    kind?: ConnectionKind;
+    /**
+     * **ADVANCED**
+     *
+     * ID of the DC to use for this call
+     */
+    dcId?: number;
+    /**
+     * **ADVANCED**
+     *
+     * DC connection manager to use for this call.
+     * Overrides `dcId` if set.
+     */
+    manager?: DcConnectionManager;
+    /**
+     * Abort signal for the call.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Whether we should not retry on -503 errors and throw {@link MtTimeoutError} immediately instead.
+     *
+     * Useful for methods like `messages.getBotCallbackAnswer` that reliably return
+     * -503 in case the upstream bot failed to respond.
+     *
+     * Only applies if the internal error handler middleware is enabled,
+     * otherwise -503 is always thrown.
+     */
+    throw503?: boolean;
+    /**
+     * Whether the `X_MIGRATE_%d` errors should be handled locally on request level
+     * instead of changing the default datacenter for the entire client.
+     *
+     * Useful for `invokeWithBusinessConnection`, as it returns a `USER_MIGRATE_%d` error
+     * that is in fact not related to the user, but to the specific request.
+     */
+    localMigrate?: boolean;
+    /**
+     * Some requests should be processed consecutively, and not in parallel.
+     * Using the same `chainId` for multiple requests will ensure that they are processed in the order
+     * of calling `.call()`.
+     *
+     * Particularly useful for `messages.sendMessage` and alike.
+     */
+    chainId?: string | number;
+}
+export interface RpcCallMiddlewareContext {
+    request: tl.RpcMethod;
+    manager: NetworkManager;
+    params?: RpcCallOptions;
+}
+export type RpcCallMiddleware<Result = unknown> = Middleware<RpcCallMiddlewareContext, Result>;
+/**
+ * Wrapper over all connection pools for a single DC.
+ */
+export declare class DcConnectionManager {
+    /** Network manager instance */
+    readonly manager: NetworkManager;
+    /** DC ID */
+    readonly dcId: number;
+    /** DC options to use */
+    readonly _dcs: DcOptions;
+    /** Whether this DC is the primary one */
+    isPrimary: boolean;
+    private _salts;
+    private _log;
+    /** Main connection pool */
+    main: MultiSessionConnection;
+    /** Upload connection pool */
+    upload: MultiSessionConnection;
+    /** Download connection pool */
+    download: MultiSessionConnection;
+    /** Download connection pool (for small files) */
+    downloadSmall: MultiSessionConnection;
+    private get _mainCountOverride();
+    constructor(
+    /** Network manager instance */
+    manager: NetworkManager, 
+    /** DC ID */
+    dcId: number, 
+    /** DC options to use */
+    _dcs: DcOptions, 
+    /** Whether this DC is the primary one */
+    isPrimary?: boolean);
+    private _setupMulti;
+    setIsPrimary(isPrimary: boolean): void;
+    setIsPremium(isPremium: boolean): void;
+    loadKeys(forcePfs?: boolean): Promise<boolean>;
+    setMainConnectionCount(count: number): void;
+    destroy(): Promise<void>;
+}
+/**
+ * Class that manages all connections to Telegram servers.
+ */
+export declare class NetworkManager {
+    readonly params: NetworkManagerParams & NetworkManagerExtraParams;
+    readonly config: ConfigManager;
+    readonly _log: Logger;
+    readonly _storage: StorageManager;
+    readonly _initConnectionParams: tl.RawInitConnectionRequest;
+    readonly _transport: TelegramTransport;
+    readonly _reconnectionStrategy: ReconnectionStrategy;
+    readonly _connectionCount: ConnectionCountDelegate;
+    protected readonly _dcConnections: Map<number, DcConnectionManager>;
+    protected _primaryDc?: DcConnectionManager;
+    protected _primaryDcRecreationPromise?: Deferred<void>;
+    private _updateHandler;
+    constructor(params: NetworkManagerParams & NetworkManagerExtraParams, config: ConfigManager);
+    private _findDcOptions;
+    private _resetOnNetworkChange?;
+    private _switchPrimaryDc;
+    private _dcCreationPromise;
+    _getOtherDc(dcId: number): Promise<DcConnectionManager>;
+    /**
+     * Perform initial connection to the default DC
+     *
+     * @param defaultDcs  Default DCs to connect to
+     */
+    connect(defaultDcs: DcOptions): Promise<void>;
+    private _pendingExports;
+    private _exportAuthTo;
+    setIsPremium(isPremium: boolean): void;
+    notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): tl.RawUser;
+    notifyLoggedOut(): void;
+    notifyNetworkChanged(connected: boolean): void;
+    resetSessions(): void;
+    private _onConfigChanged;
+    changePrimaryDc(newDc: number): Promise<void>;
+    readonly call: <T extends tl.RpcMethod>(message: T, params?: RpcCallOptions) => Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    private _composeCall;
+    private _call;
+    changeTransport(transport: TelegramTransport): Promise<void>;
+    getPoolSize(kind: ConnectionKind, dcId?: number): number;
+    getPrimaryDcId(): number;
+    destroy(): Promise<void>;
+    getMtprotoMessageId(): Long;
+    recreateDc(dcId: number): Promise<void>;
+}

package/network/network-manager.js

@@ -100,11 +100,11 @@ class DcConnectionManager {
   _setupMulti(kind) {
     const connection = this[kind];
     connection.onKeyChange.add(([idx, key]) => {
-      if (kind !== "main") {
+      if (kind !== "main" && key !== null) {
         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.manager._log.debug("key change (empty=%b) for dc %d from connection %d", key === null, this.dcId, idx);
       this.upload.setAuthKey(key);
       this.download.setAuthKey(key);
       this.downloadSmall.setAuthKey(key);
@@ -119,18 +119,10 @@ class DcConnectionManager {
     });
     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) => {
+      Promise.resolve(this.manager._storage.provider.authKeys.setTemp(this.dcId, idx, key, expires * 1e3)).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);
       });
@@ -192,14 +184,9 @@ class DcConnectionManager {
     if (this.manager.params.usePfs || forcePfs) {
       const now = Date.now();
       await Promise.all(
-        this.main._sessions.map(async (_, i) => {
+        Array.from({ length: this.main.getCount() }, 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);
-          }
+          this.main.setTempAuthKey(temp, i);
         })
       );
     }
@@ -226,7 +213,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.17.1",
+      appVersion: "0.19.0",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -544,7 +531,7 @@ class NetworkManager {
     this._resetOnNetworkChange?.();
   }
   getMtprotoMessageId() {
-    return this._primaryDc.main._sessions[0].getMessageId();
+    return this._primaryDc.main._connections[0]._session.getMessageId();
   }
   async recreateDc(dcId) {
     this._log.debug("recreating dc %d", dcId);

package/network/persistent-connection.cjs

@@ -64,6 +64,7 @@ class PersistentConnection {
     return this._fuman.isConnected;
   }
   _writer;
+  _mtproxyInfo;
   async _onOpen(conn) {
     this._updateLogPrefix();
     this.log.debug("connected");
@@ -71,6 +72,7 @@ class PersistentConnection {
     if (tag) {
       await conn.write(tag);
     }
+    this._mtproxyInfo = conn.getMtproxyInfo?.();
     const reader = new io.FramedReader(conn, this._codec);
     this._writer = new io.FramedWriter(conn, this._codec);
     while (this._sendOnceConnected.length) {
@@ -116,12 +118,18 @@ class PersistentConnection {
     this._inactive = false;
   }
   reconnect() {
+    if (this._disconnectedManually) {
+      this._disconnectedManually = false;
+      this.connect();
+      return;
+    }
     this._fuman.reconnect(true);
   }
   async disconnectManual() {
     if (this._inactivityTimeout) {
       utils.timers.clearTimeout(this._inactivityTimeout);
     }
+    this._disconnectedManually = true;
     await this._fuman.close();
   }
   async destroy() {

package/network/persistent-connection.d.cts

@@ -0,0 +1,55 @@
+import { ReconnectionStrategy } from '@fuman/net';
+import { tl } from '@mtcute/tl';
+import { BasicDcOption, ICryptoProvider, Logger } from '../utils/index.js';
+import { TelegramTransport } from './transports/abstract.js';
+import { Emitter } from '@fuman/utils';
+export interface PersistentConnectionParams {
+    crypto: ICryptoProvider;
+    transport: TelegramTransport;
+    dc: BasicDcOption;
+    testMode: boolean;
+    reconnectionStrategy: ReconnectionStrategy;
+    inactivityTimeout?: number;
+}
+/**
+ * Base class for persistent connections.
+ * Only used for {@link PersistentConnection} and used as a mean of code splitting.
+ * This class doesn't know anything about MTProto, it just manages the transport.
+ */
+export declare abstract class PersistentConnection {
+    readonly log: Logger;
+    private _uid;
+    readonly params: PersistentConnectionParams;
+    private _sendOnceConnected;
+    private _codec;
+    private _fuman;
+    protected _disconnectedManually: boolean;
+    private _inactivityTimeout;
+    _inactive: boolean;
+    _destroyed: boolean;
+    _usable: boolean;
+    readonly onWait: Emitter<number>;
+    readonly onUsable: Emitter<void>;
+    readonly onError: Emitter<Error>;
+    protected abstract onConnected(): void;
+    protected abstract onClosed(): void;
+    protected abstract handleError(err: Error): void;
+    protected abstract onMessage(data: Uint8Array): void;
+    protected constructor(params: PersistentConnectionParams, log: Logger);
+    private _updateLogPrefix;
+    get isConnected(): boolean;
+    private _writer?;
+    protected _mtproxyInfo?: tl.RawInputClientProxy;
+    private _onOpen;
+    private _onClose;
+    private _onError;
+    changeTransport(transport: TelegramTransport): Promise<void>;
+    connect(): void;
+    reconnect(): void;
+    disconnectManual(): Promise<void>;
+    destroy(): Promise<void>;
+    protected _rescheduleInactivity(): void;
+    protected _onInactivityTimeout(): void;
+    setInactivityTimeout(timeout?: number): void;
+    send(data: Uint8Array): Promise<void>;
+}

package/network/persistent-connection.d.ts

@@ -1,4 +1,5 @@
 import { ReconnectionStrategy } from '@fuman/net';
+import { tl } from '@mtcute/tl';
 import { BasicDcOption, ICryptoProvider, Logger } from '../utils/index.js';
 import { TelegramTransport } from './transports/abstract.js';
 import { Emitter } from '@fuman/utils';
@@ -24,7 +25,7 @@ export declare abstract class PersistentConnection {
     private _fuman;
     protected _disconnectedManually: boolean;
     private _inactivityTimeout;
-    private _inactive;
+    _inactive: boolean;
     _destroyed: boolean;
     _usable: boolean;
     readonly onWait: Emitter<number>;
@@ -38,6 +39,7 @@ export declare abstract class PersistentConnection {
     private _updateLogPrefix;
     get isConnected(): boolean;
     private _writer?;
+    protected _mtproxyInfo?: tl.RawInputClientProxy;
     private _onOpen;
     private _onClose;
     private _onError;

package/network/persistent-connection.js

@@ -57,6 +57,7 @@ class PersistentConnection {
     return this._fuman.isConnected;
   }
   _writer;
+  _mtproxyInfo;
   async _onOpen(conn) {
     this._updateLogPrefix();
     this.log.debug("connected");
@@ -64,6 +65,7 @@ class PersistentConnection {
     if (tag) {
       await conn.write(tag);
     }
+    this._mtproxyInfo = conn.getMtproxyInfo?.();
     const reader = new FramedReader(conn, this._codec);
     this._writer = new FramedWriter(conn, this._codec);
     while (this._sendOnceConnected.length) {
@@ -109,12 +111,18 @@ class PersistentConnection {
     this._inactive = false;
   }
   reconnect() {
+    if (this._disconnectedManually) {
+      this._disconnectedManually = false;
+      this.connect();
+      return;
+    }
     this._fuman.reconnect(true);
   }
   async disconnectManual() {
     if (this._inactivityTimeout) {
       timers.clearTimeout(this._inactivityTimeout);
     }
+    this._disconnectedManually = true;
     await this._fuman.close();
   }
   async destroy() {

package/network/server-salt.d.cts

@@ -0,0 +1,12 @@
+import { mtp } from '@mtcute/tl';
+import { default as Long } from 'long';
+export declare class ServerSaltManager {
+    private _futureSalts;
+    currentSalt: Long;
+    isFetching: boolean;
+    shouldFetchSalts(): boolean;
+    setFutureSalts(salts: mtp.RawMt_future_salt[]): void;
+    private _timer?;
+    private _scheduleNext;
+    destroy(): void;
+}

package/network/session-connection.cjs

@@ -13,6 +13,7 @@ const mtproto = require("../utils/crypto/mtproto.cjs");
 const earlyTimer = require("../utils/early-timer.cjs");
 const longUtils = require("../utils/long-utils.cjs");
 const authorization = require("./authorization.cjs");
+const mtprotoSession = require("./mtproto-session.cjs");
 const persistentConnection = require("./persistent-connection.cjs");
 const abstract = require("./transports/abstract.cjs");
 const errors = require("../types/errors.cjs");
@@ -25,19 +26,6 @@ const RPC_ERROR_ID = 558156313;
 const INVOKE_AFTER_MSG_ID = 3416209197;
 const INVOKE_AFTER_MSG_SIZE = 12;
 class SessionConnection extends persistentConnection.PersistentConnection {
-  constructor(params, _session) {
-    super(params, _session.log.create("conn"));
-    this._session = _session;
-    this._flushTimer.onTimeout(this._flush.bind(this));
-    this._pingInterval = params.pingInterval;
-    this._readerMap = params.readerMap;
-    this._writerMap = params.writerMap;
-    this._crypto = params.crypto;
-    this._salts = params.salts;
-    this._handleRawMessage = this._handleRawMessage.bind(this);
-    this._usePfs = this.params.usePfs ?? false;
-    this._online = params.platform.isOnline?.() ?? true;
-  }
   _flushTimer = new earlyTimer.EarlyTimer();
   _queuedDestroySession = [];
   // waitForMessage
@@ -51,6 +39,7 @@ class SessionConnection extends persistentConnection.PersistentConnection {
   _writerMap;
   _crypto;
   _salts;
+  _session;
   // todo: we should probably do adaptive ping interval based on rtt like tdlib:
   // https://github.com/tdlib/td/blob/91aa6c9e4d0774eabf4f8d7f3aa51239032059a6/td/mtproto/SessionConnection.h
   _pingInterval;
@@ -63,6 +52,26 @@ class SessionConnection extends persistentConnection.PersistentConnection {
   onAuthBegin = new utils.Emitter();
   onUpdate = new utils.Emitter();
   onFutureSalts = new utils.Emitter();
+  _triedReconnectingOn404 = false;
+  constructor(params, log) {
+    super(params, log.create("conn"));
+    this._session = new mtprotoSession.MtprotoSession(
+      params.crypto,
+      log.create("session"),
+      params.readerMap,
+      params.writerMap,
+      params.salts
+    );
+    this._flushTimer.onTimeout(this._flush.bind(this));
+    this._pingInterval = params.pingInterval;
+    this._readerMap = params.readerMap;
+    this._writerMap = params.writerMap;
+    this._crypto = params.crypto;
+    this._salts = params.salts;
+    this._handleRawMessage = this._handleRawMessage.bind(this);
+    this._usePfs = this.params.usePfs ?? false;
+    this._online = params.platform.isOnline?.() ?? true;
+  }
   _online;
   getAuthKey(temp = false) {
     const key = temp ? this._session._authKeyTemp : this._session._authKey;
@@ -119,6 +128,7 @@ class SessionConnection extends persistentConnection.PersistentConnection {
       this.onError.add((err) => {
         this.log.warn("caught error after destroying: %s", err);
       });
+      this._session.reset();
     }
   }
   onConnected() {
@@ -144,22 +154,27 @@ class SessionConnection extends persistentConnection.PersistentConnection {
       if (error.code === 404) {
         if (this._usePfs) {
           if (!this._isPfsBindingPending && this._session._authKeyTemp.ready) {
-            this.log.info("transport error 404, reauthorizing pfs");
+            this.log.debug("transport error 404, reauthorizing pfs");
             this._session._authKeyTemp.reset();
             this._authorizePfs();
             this._onAllFailed("temp key expired, binding started");
             return;
           } else if (this._isPfsBindingPending) {
-            this.log.info("transport error 404, pfs binding in progress");
+            this.log.debug("transport error 404, pfs binding in progress");
             this._onAllFailed("temp key expired, binding pending");
             return;
           }
         }
-        this.log.info("transport error 404, reauthorizing");
+        if (!this._triedReconnectingOn404) {
+          this.log.warn("transport error 404. trying to reconnect");
+          this._triedReconnectingOn404 = true;
+          this._resetSession();
+          return;
+        }
+        this.log.warn("transport error 404, reauthorizing");
         this._session.resetAuthKey();
         this._resetSession();
         this.onKeyChange.emit(null);
-        this.onError.emit(error);
         return;
       }
       this.log.error("transport error %d", error.code);
@@ -785,6 +800,7 @@ class SessionConnection extends persistentConnection.PersistentConnection {
       this.onUpdate.emit({ _: "updatesTooLong" });
     }
     this._salts.currentSalt = serverSalt;
+    this._triedReconnectingOn404 = false;
     this.log.debug("received new_session_created, uid = %l, first msg_id = %l", uniqueId, firstMsgId);
     for (const msgId of this._session.pendingMessages.keys()) {
       const val = this._session.pendingMessages.get(msgId);
@@ -935,7 +951,7 @@ class SessionConnection extends persistentConnection.PersistentConnection {
         layer: this.params.layer,
         query: {
           ...this.params.initConnection,
-          // proxy,
+          proxy: this._mtproxyInfo,
           query: obj
         }
       };
@@ -1001,6 +1017,7 @@ class SessionConnection extends persistentConnection.PersistentConnection {
   notifyNetworkChanged(online) {
     this._online = online;
     if (online) {
+      if (this._inactive) return;
       this.reconnect();
     } else {
       this.disconnectManual().catch((err) => {