@mtcute/core 0.25.3 → 0.25.5

package/highlevel/client.types.d.cts

@@ -24,39 +24,122 @@ import { InputStringSessionData } from './utils/string-session.js';
  */
 export type ConnectionState = 'offline' | 'connecting' | 'updating' | 'connected';
 export interface ITelegramClient {
+    /** Logger for the client */
     readonly log: Logger;
+    /** Storage manager */
     readonly storage: PublicPart<TelegramStorageManager>;
+    /** App config manager */
     readonly appConfig: PublicPart<AppConfigManager>;
+    /** Timers manager */
     readonly timers: Pick<TimersManager, 'create' | 'cancel' | 'exists'>;
+    /** Signal that will be aborted when the client is destroyed */
     readonly stopSignal: AbortSignal;
+    /** Platform used by the client */
     readonly platform: ICorePlatform;
+    /**
+     * **ADVANCED**
+     *
+     * Do all the preparations, but don't connect just yet.
+     * Useful when you want to do some preparations before
+     * connecting, like setting up session.
+     *
+     * Call {@link connect} to actually connect.
+     */
     prepare(): Promise<void>;
+    /**
+     * Initialize the connection to the primary DC.
+     *
+     * You shouldn't usually call this method directly as it is called
+     * implicitly the first time you call {@link call}.
+     */
     connect(): Promise<void>;
+    /**
+     * Terminate any connections to the Telegram servers, but keep the client usable
+     */
     disconnect(): Promise<void>;
+    /**
+     * Destroy the client and all its resources.
+     *
+     * This will terminate any connections to the Telegram servers,
+     * free all the resources, and make the client no longer usable
+     */
     destroy(): Promise<void>;
+    /** Notify the client that the user has logged in */
     notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): Promise<tl.RawUser>;
+    /** Notify the client that the user has logged out */
     notifyLoggedOut(): Promise<void>;
+    /** Notify the client that a channel has been opened */
     notifyChannelOpened(channelId: number, pts?: number): Promise<boolean>;
+    /** Notify the client that a channel has been closed */
     notifyChannelClosed(channelId: number): Promise<boolean>;
+    /** Start the updates loop */
     startUpdatesLoop(): Promise<void>;
+    /** Stop the updates loop */
     stopUpdatesLoop(): Promise<void>;
+    /** Call an RPC method */
     call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    /**
+     * Import the session from the given session string.
+     *
+     * Note that the session will only be imported in case
+     * the storage is missing authorization (i.e. does not contain
+     * auth key for the primary DC), otherwise it will be ignored (unless `force`).
+     *
+     * @param session  Session string to import
+     * @param force  Whether to overwrite existing session
+     */
     importSession(session: string | InputStringSessionData, force?: boolean): Promise<void>;
+    /**
+     * Export current session to a single *LONG* string, containing
+     * all the needed information.
+     *
+     * > **Warning!** Anyone with this string will be able
+     * > to authorize as you and do anything. Treat this
+     * > as your password, and never give it away!
+     * >
+     * > In case you have accidentally leaked this string,
+     * > make sure to revoke this session in account settings:
+     * > "Privacy & Security" > "Active sessions" >
+     * > find the one containing `mtcute` > Revoke,
+     * > or, in case this is a bot, revoke bot token
+     * > with [@BotFather](//t.me/botfather)
+     */
     exportSession(): Promise<string>;
+    /**
+     * Handle an update sent by the server in response to an RPC call
+     *
+     * @param updates  Updates to handle
+     * @param noDispatch  Whether the updates inside should not be dispatched as events
+     */
     handleClientUpdate(updates: tl.TypeUpdates, noDispatch?: boolean): void;
+    /** Emitted when a low-level `Updates` updates is received */
     onServerUpdate: Emitter<tl.TypeUpdates>;
+    /** Emitted when an update is received from the server. Requires updates loop to be running */
     onRawUpdate: Emitter<RawUpdateInfo>;
+    /** Emitted when the connection state changes */
     onConnectionState: Emitter<ConnectionState>;
+    /** Emitted when an error occurs */
     onError: Emitter<Error>;
+    /** Get the API credentials for use in authorization methods */
     getApiCredentials(): Promise<{
         id: number;
         hash: string;
     }>;
+    /** Get the number of connections of the given kind */
     getPoolSize(kind: ConnectionKind, dcId?: number): Promise<number>;
+    /** Get the primary DC ID */
     getPrimaryDcId(): Promise<number>;
+    /** Change the primary DC */
     changePrimaryDc(newDc: number): Promise<void>;
+    /** Compute SRP parameters for the given password */
     computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;
+    /** Compute new password hash for the given algorithm and password */
     computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+    /** Generate a new time-based MTProto message ID */
     getMtprotoMessageId(): Promise<Long>;
+    /**
+     * **ADVANCED**
+     * Recreate the given DC, forcefully using the IP taken from server config.
+     */
     recreateDc(dcId: number): Promise<void>;
 }

package/highlevel/client.types.d.ts

@@ -24,39 +24,122 @@ import { InputStringSessionData } from './utils/string-session.js';
  */
 export type ConnectionState = 'offline' | 'connecting' | 'updating' | 'connected';
 export interface ITelegramClient {
+    /** Logger for the client */
     readonly log: Logger;
+    /** Storage manager */
     readonly storage: PublicPart<TelegramStorageManager>;
+    /** App config manager */
     readonly appConfig: PublicPart<AppConfigManager>;
+    /** Timers manager */
     readonly timers: Pick<TimersManager, 'create' | 'cancel' | 'exists'>;
+    /** Signal that will be aborted when the client is destroyed */
     readonly stopSignal: AbortSignal;
+    /** Platform used by the client */
     readonly platform: ICorePlatform;
+    /**
+     * **ADVANCED**
+     *
+     * Do all the preparations, but don't connect just yet.
+     * Useful when you want to do some preparations before
+     * connecting, like setting up session.
+     *
+     * Call {@link connect} to actually connect.
+     */
     prepare(): Promise<void>;
+    /**
+     * Initialize the connection to the primary DC.
+     *
+     * You shouldn't usually call this method directly as it is called
+     * implicitly the first time you call {@link call}.
+     */
     connect(): Promise<void>;
+    /**
+     * Terminate any connections to the Telegram servers, but keep the client usable
+     */
     disconnect(): Promise<void>;
+    /**
+     * Destroy the client and all its resources.
+     *
+     * This will terminate any connections to the Telegram servers,
+     * free all the resources, and make the client no longer usable
+     */
     destroy(): Promise<void>;
+    /** Notify the client that the user has logged in */
     notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): Promise<tl.RawUser>;
+    /** Notify the client that the user has logged out */
     notifyLoggedOut(): Promise<void>;
+    /** Notify the client that a channel has been opened */
     notifyChannelOpened(channelId: number, pts?: number): Promise<boolean>;
+    /** Notify the client that a channel has been closed */
     notifyChannelClosed(channelId: number): Promise<boolean>;
+    /** Start the updates loop */
     startUpdatesLoop(): Promise<void>;
+    /** Stop the updates loop */
     stopUpdatesLoop(): Promise<void>;
+    /** Call an RPC method */
     call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    /**
+     * Import the session from the given session string.
+     *
+     * Note that the session will only be imported in case
+     * the storage is missing authorization (i.e. does not contain
+     * auth key for the primary DC), otherwise it will be ignored (unless `force`).
+     *
+     * @param session  Session string to import
+     * @param force  Whether to overwrite existing session
+     */
     importSession(session: string | InputStringSessionData, force?: boolean): Promise<void>;
+    /**
+     * Export current session to a single *LONG* string, containing
+     * all the needed information.
+     *
+     * > **Warning!** Anyone with this string will be able
+     * > to authorize as you and do anything. Treat this
+     * > as your password, and never give it away!
+     * >
+     * > In case you have accidentally leaked this string,
+     * > make sure to revoke this session in account settings:
+     * > "Privacy & Security" > "Active sessions" >
+     * > find the one containing `mtcute` > Revoke,
+     * > or, in case this is a bot, revoke bot token
+     * > with [@BotFather](//t.me/botfather)
+     */
     exportSession(): Promise<string>;
+    /**
+     * Handle an update sent by the server in response to an RPC call
+     *
+     * @param updates  Updates to handle
+     * @param noDispatch  Whether the updates inside should not be dispatched as events
+     */
     handleClientUpdate(updates: tl.TypeUpdates, noDispatch?: boolean): void;
+    /** Emitted when a low-level `Updates` updates is received */
     onServerUpdate: Emitter<tl.TypeUpdates>;
+    /** Emitted when an update is received from the server. Requires updates loop to be running */
     onRawUpdate: Emitter<RawUpdateInfo>;
+    /** Emitted when the connection state changes */
     onConnectionState: Emitter<ConnectionState>;
+    /** Emitted when an error occurs */
     onError: Emitter<Error>;
+    /** Get the API credentials for use in authorization methods */
     getApiCredentials(): Promise<{
         id: number;
         hash: string;
     }>;
+    /** Get the number of connections of the given kind */
     getPoolSize(kind: ConnectionKind, dcId?: number): Promise<number>;
+    /** Get the primary DC ID */
     getPrimaryDcId(): Promise<number>;
+    /** Change the primary DC */
     changePrimaryDc(newDc: number): Promise<void>;
+    /** Compute SRP parameters for the given password */
     computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;
+    /** Compute new password hash for the given algorithm and password */
     computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+    /** Generate a new time-based MTProto message ID */
     getMtprotoMessageId(): Promise<Long>;
+    /**
+     * **ADVANCED**
+     * Recreate the given DC, forcefully using the IP taken from server config.
+     */
     recreateDc(dcId: number): Promise<void>;
 }

package/highlevel/methods/users/resolve-peer.cjs

@@ -133,32 +133,40 @@ async function resolvePeer(client, peerId, force = false) {
   }
   switch (peerType) {
     case "user": {
-      const res = await batchedQueries._getUsersBatched(client, {
-        _: "inputUser",
-        userId: bareId,
-        accessHash: Long.ZERO
-      });
-      if (res != null && res._ === "user" && res.accessHash != null) {
-        return {
-          _: "inputPeerUser",
+      try {
+        const res = await batchedQueries._getUsersBatched(client, {
+          _: "inputUser",
           userId: bareId,
-          accessHash: res.accessHash
-        };
+          accessHash: Long.ZERO
+        });
+        if (res != null && res._ === "user" && res.accessHash != null) {
+          return {
+            _: "inputPeerUser",
+            userId: bareId,
+            accessHash: res.accessHash
+          };
+        }
+      } catch (e) {
+        if (!tl.tl.RpcError.is(e, "USER_INVALID")) throw e;
       }
       break;
     }
     case "channel": {
-      const res = await batchedQueries._getChannelsBatched(client, {
-        _: "inputChannel",
-        channelId: bareId,
-        accessHash: Long.ZERO
-      });
-      if (res != null && res._ === "channel" && res.accessHash != null) {
-        return {
-          _: "inputPeerChannel",
+      try {
+        const res = await batchedQueries._getChannelsBatched(client, {
+          _: "inputChannel",
           channelId: bareId,
-          accessHash: res.accessHash
-        };
+          accessHash: Long.ZERO
+        });
+        if (res != null && res._ === "channel" && res.accessHash != null) {
+          return {
+            _: "inputPeerChannel",
+            channelId: bareId,
+            accessHash: res.accessHash
+          };
+        }
+      } catch (e) {
+        if (!tl.tl.RpcError.is(e, "CHANNEL_INVALID")) throw e;
       }
       break;
     }

package/highlevel/methods/users/resolve-peer.js

@@ -126,32 +126,40 @@ async function resolvePeer(client, peerId, force = false) {
   }
   switch (peerType) {
     case "user": {
-      const res = await _getUsersBatched(client, {
-        _: "inputUser",
-        userId: bareId,
-        accessHash: Long.ZERO
-      });
-      if (res != null && res._ === "user" && res.accessHash != null) {
-        return {
-          _: "inputPeerUser",
+      try {
+        const res = await _getUsersBatched(client, {
+          _: "inputUser",
           userId: bareId,
-          accessHash: res.accessHash
-        };
+          accessHash: Long.ZERO
+        });
+        if (res != null && res._ === "user" && res.accessHash != null) {
+          return {
+            _: "inputPeerUser",
+            userId: bareId,
+            accessHash: res.accessHash
+          };
+        }
+      } catch (e) {
+        if (!tl.RpcError.is(e, "USER_INVALID")) throw e;
       }
       break;
     }
     case "channel": {
-      const res = await _getChannelsBatched(client, {
-        _: "inputChannel",
-        channelId: bareId,
-        accessHash: Long.ZERO
-      });
-      if (res != null && res._ === "channel" && res.accessHash != null) {
-        return {
-          _: "inputPeerChannel",
+      try {
+        const res = await _getChannelsBatched(client, {
+          _: "inputChannel",
           channelId: bareId,
-          accessHash: res.accessHash
-        };
+          accessHash: Long.ZERO
+        });
+        if (res != null && res._ === "channel" && res.accessHash != null) {
+          return {
+            _: "inputPeerChannel",
+            channelId: bareId,
+            accessHash: res.accessHash
+          };
+        }
+      } catch (e) {
+        if (!tl.RpcError.is(e, "CHANNEL_INVALID")) throw e;
       }
       break;
     }

package/highlevel/updates/manager.cjs

@@ -219,9 +219,9 @@ class UpdatesManager {
     }
     if (this.pendingUpdateContainers.length % WARN_EVERY === 0) {
       if (this.updatesLoopActive) {
-        this.log.warn("%d pending update containers, but the updates loop is not active. did you forget to start it?", this.pendingUpdateContainers.length);
-      } else {
         this.log.warn("%d pending update containers, can't keep up!", this.pendingUpdateContainers.length);
+      } else {
+        this.log.warn("%d pending update containers, but the updates loop is not active. did you forget to start it?", this.pendingUpdateContainers.length);
       }
     }
     this.updatesLoopCv.notify();

package/highlevel/updates/manager.js

@@ -212,9 +212,9 @@ class UpdatesManager {
     }
     if (this.pendingUpdateContainers.length % WARN_EVERY === 0) {
       if (this.updatesLoopActive) {
-        this.log.warn("%d pending update containers, but the updates loop is not active. did you forget to start it?", this.pendingUpdateContainers.length);
-      } else {
         this.log.warn("%d pending update containers, can't keep up!", this.pendingUpdateContainers.length);
+      } else {
+        this.log.warn("%d pending update containers, but the updates loop is not active. did you forget to start it?", this.pendingUpdateContainers.length);
       }
     }
     this.updatesLoopCv.notify();

package/network/network-manager.cjs

@@ -225,7 +225,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.25.3",
+      appVersion: "0.25.5",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/network/network-manager.js

@@ -218,7 +218,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.25.3",
+      appVersion: "0.25.5",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/network/session-connection.cjs

@@ -536,8 +536,9 @@ class SessionConnection extends persistentConnection.PersistentConnection {
       this.log.error("received rpc_result for %s request %l", msg._, reqMsgId);
       return;
     }
-    longUtils.removeFromLongArray(this._session.queuedStateReq, reqMsgId);
     const rpc = msg.rpc;
+    longUtils.removeFromLongArray(this._session.queuedStateReq, reqMsgId);
+    this._session.getStateSchedule.remove(rpc);
     rpc.resetAbortSignal?.();
     const resultConstructorId = message.peekUint();
     let result;
@@ -660,7 +661,6 @@ class SessionConnection extends persistentConnection.PersistentConnection {
           this._onMessageAcked(rpc.containerId);
         }
         longUtils.removeFromLongArray(this._session.queuedResendReq, msgId);
-        this._session.getStateSchedule.remove(rpc);
         break;
       }
       case "bind":

package/network/session-connection.js

@@ -529,8 +529,9 @@ class SessionConnection extends PersistentConnection {
       this.log.error("received rpc_result for %s request %l", msg._, reqMsgId);
       return;
     }
-    removeFromLongArray(this._session.queuedStateReq, reqMsgId);
     const rpc = msg.rpc;
+    removeFromLongArray(this._session.queuedStateReq, reqMsgId);
+    this._session.getStateSchedule.remove(rpc);
     rpc.resetAbortSignal?.();
     const resultConstructorId = message.peekUint();
     let result;
@@ -653,7 +654,6 @@ class SessionConnection extends PersistentConnection {
           this._onMessageAcked(rpc.containerId);
         }
         removeFromLongArray(this._session.queuedResendReq, msgId);
-        this._session.getStateSchedule.remove(rpc);
         break;
       }
       case "bind":

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@mtcute/core",
     "type": "module",
-    "version": "0.25.3",
+    "version": "0.25.5",
     "description": "Type-safe library for MTProto (Telegram API)",
     "license": "MIT",
     "scripts": {},
@@ -10,7 +10,7 @@
         "@fuman/net": "0.0.15",
         "@fuman/utils": "0.0.15",
         "@mtcute/file-id": "^0.24.3",
-        "@mtcute/tl": "^208.0.0",
+        "@mtcute/tl": "^209.0.0",
         "@mtcute/tl-runtime": "^0.24.3",
         "@types/events": "3.0.0",
         "long": "5.2.3"