@mtcute/core 0.30.3 → 0.32.0

package/network/client.d.cts

@@ -156,6 +156,7 @@ export declare class MtClient {
     readonly log: Logger;
     readonly network: NetworkManager;
     private _abortController;
+    /** Signal that is aborted when the client is destroyed */
     readonly stopSignal: AbortSignal;
     readonly onUsable: Emitter<void>;
     readonly onConnecting: Emitter<void>;

package/network/client.d.ts

@@ -156,6 +156,7 @@ export declare class MtClient {
     readonly log: Logger;
     readonly network: NetworkManager;
     private _abortController;
+    /** Signal that is aborted when the client is destroyed */
     readonly stopSignal: AbortSignal;
     readonly onUsable: Emitter<void>;
     readonly onConnecting: Emitter<void>;

package/network/client.js

@@ -63,7 +63,6 @@ class MtClient {
         onConnecting: this.onConnecting.emit.bind(this.onConnecting),
         onNetworkChanged: this.onNetworkChanged.emit.bind(this.onNetworkChanged),
         onUpdate: this.onUpdate.emit.bind(this.onUpdate),
-        stopSignal: this.stopSignal,
         platform: params.platform,
         ...dropUndefined(params.network)
       },
@@ -99,6 +98,7 @@ class MtClient {
   log;
   network;
   _abortController;
+  /** Signal that is aborted when the client is destroyed */
   stopSignal;
   onUsable = new Emitter();
   onConnecting = new Emitter();
@@ -136,12 +136,11 @@ class MtClient {
     return this._connect.run();
   }
   async disconnect() {
-    await this.network.destroy();
+    await this.network.disconnect();
     await this.storage.save();
     this._config.destroy();
     this._prepare.reset();
     this._connect.reset();
-    this._abortController.abort();
     this.log.debug("client disconnected");
   }
   /**
@@ -150,6 +149,8 @@ class MtClient {
    * **Note**: must be called *after* {@link disconnect}
    */
   async destroy() {
+    this._abortController.abort();
+    await this.network.destroy();
     await this.storage.destroy();
     this.log.debug("client destroyed");
   }

package/network/middlewares/flood-waiter.cjs

@@ -35,7 +35,7 @@ function floodWaiter(options) {
       if (delta <= minStoredWait) {
         storage.delete(method);
       } else if (delta <= floodSleepThreshold) {
-        await miscUtils.sleepWithAbort(delta, abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal));
+        await miscUtils.sleepWithAbort(delta, abortSignal.combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal));
         storage.delete(method);
       } else {
         return {
@@ -74,7 +74,7 @@ function floodWaiter(options) {
           }
           await miscUtils.sleepWithAbort(
             ms,
-            abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+            abortSignal.combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal)
           );
           continue;
         }

package/network/middlewares/flood-waiter.js

@@ -28,7 +28,7 @@ function floodWaiter(options) {
       if (delta <= minStoredWait) {
         storage.delete(method);
       } else if (delta <= floodSleepThreshold) {
-        await sleepWithAbort(delta, combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal));
+        await sleepWithAbort(delta, combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal));
         storage.delete(method);
       } else {
         return {
@@ -67,7 +67,7 @@ function floodWaiter(options) {
           }
           await sleepWithAbort(
             ms,
-            combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+            combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal)
           );
           continue;
         }

package/network/middlewares/internal-errors.cjs

@@ -50,7 +50,7 @@ function internalErrorsHandler(params) {
         if (waitSeconds > 0) {
           await miscUtils.sleepWithAbort(
             waitSeconds * 1e3,
-            abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+            abortSignal.combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal)
           );
         }
         continue;

package/network/middlewares/internal-errors.js

@@ -43,7 +43,7 @@ function internalErrorsHandler(params) {
         if (waitSeconds > 0) {
           await sleepWithAbort(
             waitSeconds * 1e3,
-            combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+            combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal)
           );
         }
         continue;

package/network/middlewares/media-throttle.cjs

@@ -52,7 +52,7 @@ function mediaThrottle(params) {
     const dcId = ctx.params?.dcId ?? ctx.manager.getPrimaryDcId();
     const limiter = getLimiter(kind, dcId, ctx.manager.params.isPremium);
     if (!limiter.tryAcquire(bytes)) {
-      const abortSignal$1 = abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal);
+      const abortSignal$1 = abortSignal.combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal);
       await limiter.acquire(bytes, abortSignal$1);
     }
     try {

package/network/middlewares/media-throttle.js

@@ -45,7 +45,7 @@ function mediaThrottle(params) {
     const dcId = ctx.params?.dcId ?? ctx.manager.getPrimaryDcId();
     const limiter = getLimiter(kind, dcId, ctx.manager.params.isPremium);
     if (!limiter.tryAcquire(bytes)) {
-      const abortSignal = combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal);
+      const abortSignal = combineAbortSignals(ctx.manager.teardownSignal, ctx.params?.abortSignal);
       await limiter.acquire(bytes, abortSignal);
     }
     try {

package/network/mtproto-session.cjs

@@ -201,13 +201,20 @@ class MtprotoSession {
     else writer.object(content);
     return messageId;
   }
-  resetLastPing(withTime = false) {
+  resetLastPing(withTime = false, keepPending = false) {
     if (withTime) this.lastPingTime = 0;
-    if (!this.lastPingMsgId.isZero()) {
+    if (!keepPending && !this.lastPingMsgId.isZero()) {
       this.pendingMessages.delete(this.lastPingMsgId);
     }
     this.lastPingMsgId = Long.ZERO;
   }
+  forgetPendingPings() {
+    for (const [msgId, info] of this.pendingMessages) {
+      if (info._ === "ping") this.pendingMessages.delete(msgId);
+    }
+    this.lastPingTime = 0;
+    this.lastPingMsgId = Long.ZERO;
+  }
   addToChain(chainId, msgId) {
     const prevMsgId = this.chains.get(chainId);
     this.chains.set(chainId, msgId);

package/network/mtproto-session.d.cts

@@ -43,6 +43,7 @@ export type PendingMessage = {
 } | {
     _: 'ping';
     pingId: Long;
+    sentAt: number;
     containerId: Long;
 } | {
     _: 'destroy_session';
@@ -120,7 +121,8 @@ export declare class MtprotoSession {
     /** Decrypt a single MTProto message using session's keys */
     decryptMessage(data: Uint8Array, callback: Parameters<AuthKey['decryptMessage']>[2]): void;
     writeMessage(writer: TlBinaryWriter, content: tl.TlObject | mtp.TlObject | Uint8Array, isContentRelated?: boolean): Long;
-    resetLastPing(withTime?: boolean): void;
+    resetLastPing(withTime?: boolean, keepPending?: boolean): void;
+    forgetPendingPings(): void;
     addToChain(chainId: string | number, msgId: Long): Long | undefined;
     removeFromChain(chainId: string | number, msgId: Long): void;
     getPendingChainedFails(chainId: string | number): SortedArray<PendingRpc>;

package/network/mtproto-session.d.ts

@@ -43,6 +43,7 @@ export type PendingMessage = {
 } | {
     _: 'ping';
     pingId: Long;
+    sentAt: number;
     containerId: Long;
 } | {
     _: 'destroy_session';
@@ -120,7 +121,8 @@ export declare class MtprotoSession {
     /** Decrypt a single MTProto message using session's keys */
     decryptMessage(data: Uint8Array, callback: Parameters<AuthKey['decryptMessage']>[2]): void;
     writeMessage(writer: TlBinaryWriter, content: tl.TlObject | mtp.TlObject | Uint8Array, isContentRelated?: boolean): Long;
-    resetLastPing(withTime?: boolean): void;
+    resetLastPing(withTime?: boolean, keepPending?: boolean): void;
+    forgetPendingPings(): void;
     addToChain(chainId: string | number, msgId: Long): Long | undefined;
     removeFromChain(chainId: string | number, msgId: Long): void;
     getPendingChainedFails(chainId: string | number): SortedArray<PendingRpc>;

package/network/mtproto-session.js

@@ -194,13 +194,20 @@ class MtprotoSession {
     else writer.object(content);
     return messageId;
   }
-  resetLastPing(withTime = false) {
+  resetLastPing(withTime = false, keepPending = false) {
     if (withTime) this.lastPingTime = 0;
-    if (!this.lastPingMsgId.isZero()) {
+    if (!keepPending && !this.lastPingMsgId.isZero()) {
       this.pendingMessages.delete(this.lastPingMsgId);
     }
     this.lastPingMsgId = Long.ZERO;
   }
+  forgetPendingPings() {
+    for (const [msgId, info] of this.pendingMessages) {
+      if (info._ === "ping") this.pendingMessages.delete(msgId);
+    }
+    this.lastPingTime = 0;
+    this.lastPingMsgId = Long.ZERO;
+  }
   addToChain(chainId, msgId) {
     const prevMsgId = this.chains.get(chainId);
     this.chains.set(chainId, msgId);

package/network/mtproxy/index.cjs

@@ -11,6 +11,7 @@ const errors = require("../../types/errors.cjs");
 const _fakeTls = require("./_fake-tls.cjs");
 const obfuscated = require("../transports/obfuscated.cjs");
 const intermediate = require("../transports/intermediate.cjs");
+const abstract = require("../transports/abstract.cjs");
 const MAX_DOMAIN_LENGTH = 182;
 const TLS_START_SERVER = [
   new Uint8Array([22, 3, 3]),
@@ -86,13 +87,13 @@ class BaseMtProxyTransport {
       new obfuscated.ObfuscatedPacketCodec(new intermediate.PaddedIntermediatePacketCodec(), proxy)
     );
   }
-  async connect() {
+  async connect(_dc, abortSignal) {
     const conn = await this._connectTcp({
       address: this._proxy.host,
       port: this._proxy.port
-    });
+    }, abortSignal);
     if (this._fakeTlsDomain) {
-      await this._handleConnectFakeTls(conn);
+      await abstract.performHandshakeWithAbort(conn, abortSignal, () => this._handleConnectFakeTls(conn));
     }
     return conn;
   }

package/network/mtproxy/index.d.cts

@@ -23,7 +23,7 @@ export interface MtProxySettings {
  * Base for a TCP transport that connects via an MTProxy
  */
 export declare abstract class BaseMtProxyTransport implements TelegramTransport {
-    abstract _connectTcp(endpoint: TcpEndpoint): Promise<ITcpConnection>;
+    abstract _connectTcp(endpoint: TcpEndpoint, abortSignal: AbortSignal): Promise<ITcpConnection>;
     readonly _proxy: MtProxySettings;
     private _rawSecret;
     private _randomPadding;
@@ -37,6 +37,6 @@ export declare abstract class BaseMtProxyTransport implements TelegramTransport
     constructor(proxy: MtProxySettings);
     getMtproxyInfo(): tl.RawInputClientProxy;
     packetCodec(dc: BasicDcOption): IPacketCodec;
-    connect(): Promise<ITelegramConnection>;
+    connect(_dc: BasicDcOption, abortSignal: AbortSignal): Promise<ITelegramConnection>;
     private _handleConnectFakeTls;
 }

package/network/mtproxy/index.d.ts

@@ -23,7 +23,7 @@ export interface MtProxySettings {
  * Base for a TCP transport that connects via an MTProxy
  */
 export declare abstract class BaseMtProxyTransport implements TelegramTransport {
-    abstract _connectTcp(endpoint: TcpEndpoint): Promise<ITcpConnection>;
+    abstract _connectTcp(endpoint: TcpEndpoint, abortSignal: AbortSignal): Promise<ITcpConnection>;
     readonly _proxy: MtProxySettings;
     private _rawSecret;
     private _randomPadding;
@@ -37,6 +37,6 @@ export declare abstract class BaseMtProxyTransport implements TelegramTransport
     constructor(proxy: MtProxySettings);
     getMtproxyInfo(): tl.RawInputClientProxy;
     packetCodec(dc: BasicDcOption): IPacketCodec;
-    connect(): Promise<ITelegramConnection>;
+    connect(_dc: BasicDcOption, abortSignal: AbortSignal): Promise<ITelegramConnection>;
     private _handleConnectFakeTls;
 }

package/network/mtproxy/index.js

@@ -4,6 +4,7 @@ import { MtSecurityError, MtUnsupportedError } from "../../types/errors.js";
 import { FakeTlsPacketCodec, generateFakeTlsHeader } from "./_fake-tls.js";
 import { ObfuscatedPacketCodec } from "../transports/obfuscated.js";
 import { PaddedIntermediatePacketCodec, IntermediatePacketCodec } from "../transports/intermediate.js";
+import { performHandshakeWithAbort } from "../transports/abstract.js";
 const MAX_DOMAIN_LENGTH = 182;
 const TLS_START_SERVER = [
   new Uint8Array([22, 3, 3]),
@@ -79,13 +80,13 @@ class BaseMtProxyTransport {
       new ObfuscatedPacketCodec(new PaddedIntermediatePacketCodec(), proxy)
     );
   }
-  async connect() {
+  async connect(_dc, abortSignal) {
     const conn = await this._connectTcp({
       address: this._proxy.host,
       port: this._proxy.port
-    });
+    }, abortSignal);
     if (this._fakeTlsDomain) {
-      await this._handleConnectFakeTls(conn);
+      await performHandshakeWithAbort(conn, abortSignal, () => this._handleConnectFakeTls(conn));
     }
     return conn;
   }

package/network/network-manager.cjs

@@ -227,7 +227,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.3",
+      appVersion: "0.32.0",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -279,34 +279,45 @@ class NetworkManager {
     return { main, media };
   }
   _resetOnNetworkChange;
+  _destroyed = false;
+  _teardownAbort = new AbortController();
+  /** Signal that is aborted when the network manager is disconnected or destroyed */
+  get teardownSignal() {
+    return this._teardownAbort.signal;
+  }
+  _onPrimaryUsable = () => this.params.onUsable();
+  _onPrimaryWait = () => this.params.onConnecting();
+  _onPrimaryUpdate = (update) => this._updateHandler(update, false);
   _switchPrimaryDc(dc) {
     if (this._primaryDc && this._primaryDc !== dc) {
       this._primaryDc.setIsPrimary(false);
+      this._primaryDc.main.onUsable.remove(this._onPrimaryUsable);
+      this._primaryDc.main.onWait.remove(this._onPrimaryWait);
+      this._primaryDc.main.onUpdate.remove(this._onPrimaryUpdate);
     }
     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);
-    });
+    dc.main.onUsable.remove(this._onPrimaryUsable);
+    dc.main.onWait.remove(this._onPrimaryWait);
+    dc.main.onUpdate.remove(this._onPrimaryUpdate);
+    dc.main.onUsable.add(this._onPrimaryUsable);
+    dc.main.onWait.add(this._onPrimaryWait);
+    dc.main.onUpdate.add(this._onPrimaryUpdate);
     return dc.loadKeys().then(() => dc.main.ensureConnected());
   }
   _dcCreationPromise = /* @__PURE__ */ new Map();
   async _getOtherDc(dcId) {
+    if (this._destroyed) {
+      throw new errors.MtcuteError("Network manager is destroyed");
+    }
     if (!this._dcConnections.has(dcId)) {
       if (this._dcCreationPromise.has(dcId)) {
         await this._dcCreationPromise.get(dcId);
         return utils.asNonNull(this._dcConnections.get(dcId));
       }
       const promise = new utils.Deferred();
+      promise.promise.catch(utils.noop);
       this._dcCreationPromise.set(dcId, promise.promise);
       this._log.debug("creating new DC %d", dcId);
       try {
@@ -323,7 +334,7 @@ class NetworkManager {
         this._log.debug("dc %d was not created: %e", dcId, e);
         promise.reject(e);
         this._dcCreationPromise.delete(dcId);
-        return this._getOtherDc(dcId);
+        throw e;
       }
     }
     return this._dcConnections.get(dcId);
@@ -334,9 +345,15 @@ class NetworkManager {
    * @param defaultDcs  Default DCs to connect to
    */
   async connect(defaultDcs) {
+    if (this._destroyed) {
+      throw new errors.MtcuteError("Network manager is destroyed");
+    }
     if (defaultDcs.main.id !== defaultDcs.media.id) {
       throw new errors.MtArgumentError("Default DCs must be the same");
     }
+    if (this._teardownAbort.signal.aborted) {
+      this._teardownAbort = new AbortController();
+    }
     if (this._dcConnections.has(defaultDcs.main.id)) {
       throw new errors.MtArgumentError("DC manager already exists");
     }
@@ -375,11 +392,12 @@ class NetworkManager {
       }
       typeAssertions.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;
+    } finally {
+      this._pendingExports.delete(manager.dcId);
     }
   }
   setIsPremium(isPremium) {
@@ -449,6 +467,9 @@ class NetworkManager {
     }
   }
   async changePrimaryDc(newDc) {
+    if (this._destroyed) {
+      throw new errors.MtcuteError("Network manager is destroyed");
+    }
     if (newDc === this._primaryDc?.dcId) return;
     const options = await this._findDcOptions(newDc);
     if (!this._dcConnections.has(newDc)) {
@@ -581,13 +602,20 @@ class NetworkManager {
     if (!this._primaryDc) throw new errors.MtcuteError("Not connected to any DC");
     return this._primaryDc.dcId;
   }
-  async destroy() {
+  async disconnect() {
+    this._teardownAbort.abort();
+    this._primaryDc = void 0;
     for (const dc of this._dcConnections.values()) {
       await dc.destroy();
     }
     this._dcConnections.clear();
-    this.config.onUpdated.remove(this._onConfigChanged);
     this._resetOnNetworkChange?.();
+    this._resetOnNetworkChange = void 0;
+  }
+  async destroy() {
+    this._destroyed = true;
+    await this.disconnect();
+    this.config.onUpdated.remove(this._onConfigChanged);
   }
   getMtprotoMessageId() {
     return this._primaryDc.main._connections[0]._session.getMessageId();

package/network/network-manager.d.cts

@@ -36,7 +36,6 @@ export interface NetworkManagerParams {
     onUsable: () => void;
     onConnecting: () => void;
     onNetworkChanged: (connected: boolean) => void;
-    stopSignal: AbortSignal;
 }
 export type ConnectionCountDelegate = (kind: ConnectionKind, dcId: number, isPremium: boolean) => number;
 /**
@@ -238,13 +237,20 @@ export declare class NetworkManager {
     readonly _transport: TelegramTransport;
     readonly _reconnectionStrategy: ReconnectionStrategy;
     readonly _connectionCount: ConnectionCountDelegate;
-    protected readonly _dcConnections: Map<number, DcConnectionManager>;
-    protected _primaryDc?: DcConnectionManager;
+    readonly _dcConnections: Map<number, DcConnectionManager>;
+    _primaryDc?: DcConnectionManager;
     protected _primaryDcRecreationPromise?: Deferred<void>;
     private _updateHandler;
     constructor(params: NetworkManagerParams & NetworkManagerExtraParams, config: ConfigManager);
     private _findDcOptions;
     private _resetOnNetworkChange?;
+    private _destroyed;
+    private _teardownAbort;
+    /** Signal that is aborted when the network manager is disconnected or destroyed */
+    get teardownSignal(): AbortSignal;
+    private _onPrimaryUsable;
+    private _onPrimaryWait;
+    private _onPrimaryUpdate;
     private _switchPrimaryDc;
     private _dcCreationPromise;
     _getOtherDc(dcId: number): Promise<DcConnectionManager>;
@@ -271,6 +277,7 @@ export declare class NetworkManager {
     changeTransport(transport: TelegramTransport): Promise<void>;
     getPoolSize(kind: ConnectionKind, dcId?: number): number;
     getPrimaryDcId(): number;
+    disconnect(): Promise<void>;
     destroy(): Promise<void>;
     getMtprotoMessageId(): Long;
     recreateDc(dcId: number): Promise<void>;

package/network/network-manager.d.ts

@@ -36,7 +36,6 @@ export interface NetworkManagerParams {
     onUsable: () => void;
     onConnecting: () => void;
     onNetworkChanged: (connected: boolean) => void;
-    stopSignal: AbortSignal;
 }
 export type ConnectionCountDelegate = (kind: ConnectionKind, dcId: number, isPremium: boolean) => number;
 /**
@@ -238,13 +237,20 @@ export declare class NetworkManager {
     readonly _transport: TelegramTransport;
     readonly _reconnectionStrategy: ReconnectionStrategy;
     readonly _connectionCount: ConnectionCountDelegate;
-    protected readonly _dcConnections: Map<number, DcConnectionManager>;
-    protected _primaryDc?: DcConnectionManager;
+    readonly _dcConnections: Map<number, DcConnectionManager>;
+    _primaryDc?: DcConnectionManager;
     protected _primaryDcRecreationPromise?: Deferred<void>;
     private _updateHandler;
     constructor(params: NetworkManagerParams & NetworkManagerExtraParams, config: ConfigManager);
     private _findDcOptions;
     private _resetOnNetworkChange?;
+    private _destroyed;
+    private _teardownAbort;
+    /** Signal that is aborted when the network manager is disconnected or destroyed */
+    get teardownSignal(): AbortSignal;
+    private _onPrimaryUsable;
+    private _onPrimaryWait;
+    private _onPrimaryUpdate;
     private _switchPrimaryDc;
     private _dcCreationPromise;
     _getOtherDc(dcId: number): Promise<DcConnectionManager>;
@@ -271,6 +277,7 @@ export declare class NetworkManager {
     changeTransport(transport: TelegramTransport): Promise<void>;
     getPoolSize(kind: ConnectionKind, dcId?: number): number;
     getPrimaryDcId(): number;
+    disconnect(): Promise<void>;
     destroy(): Promise<void>;
     getMtprotoMessageId(): Long;
     recreateDc(dcId: number): Promise<void>;

package/network/network-manager.js

@@ -1,5 +1,5 @@
 import { defaultReconnectionStrategy } from "@fuman/net";
-import { asNonNull, Deferred, LruMap, composeMiddlewares } from "@fuman/utils";
+import { asNonNull, Deferred, noop, LruMap, composeMiddlewares } from "@fuman/utils";
 import { dropUndefined } from "../utils/misc-utils.js";
 import { isTlRpcError, assertTypeIs } from "../utils/type-assertions.js";
 import "@mtcute/tl-runtime";
@@ -220,7 +220,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.3",
+      appVersion: "0.32.0",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -272,34 +272,45 @@ class NetworkManager {
     return { main, media };
   }
   _resetOnNetworkChange;
+  _destroyed = false;
+  _teardownAbort = new AbortController();
+  /** Signal that is aborted when the network manager is disconnected or destroyed */
+  get teardownSignal() {
+    return this._teardownAbort.signal;
+  }
+  _onPrimaryUsable = () => this.params.onUsable();
+  _onPrimaryWait = () => this.params.onConnecting();
+  _onPrimaryUpdate = (update) => this._updateHandler(update, false);
   _switchPrimaryDc(dc) {
     if (this._primaryDc && this._primaryDc !== dc) {
       this._primaryDc.setIsPrimary(false);
+      this._primaryDc.main.onUsable.remove(this._onPrimaryUsable);
+      this._primaryDc.main.onWait.remove(this._onPrimaryWait);
+      this._primaryDc.main.onUpdate.remove(this._onPrimaryUpdate);
     }
     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);
-    });
+    dc.main.onUsable.remove(this._onPrimaryUsable);
+    dc.main.onWait.remove(this._onPrimaryWait);
+    dc.main.onUpdate.remove(this._onPrimaryUpdate);
+    dc.main.onUsable.add(this._onPrimaryUsable);
+    dc.main.onWait.add(this._onPrimaryWait);
+    dc.main.onUpdate.add(this._onPrimaryUpdate);
     return dc.loadKeys().then(() => dc.main.ensureConnected());
   }
   _dcCreationPromise = /* @__PURE__ */ new Map();
   async _getOtherDc(dcId) {
+    if (this._destroyed) {
+      throw new MtcuteError("Network manager is destroyed");
+    }
     if (!this._dcConnections.has(dcId)) {
       if (this._dcCreationPromise.has(dcId)) {
         await this._dcCreationPromise.get(dcId);
         return asNonNull(this._dcConnections.get(dcId));
       }
       const promise = new Deferred();
+      promise.promise.catch(noop);
       this._dcCreationPromise.set(dcId, promise.promise);
       this._log.debug("creating new DC %d", dcId);
       try {
@@ -316,7 +327,7 @@ class NetworkManager {
         this._log.debug("dc %d was not created: %e", dcId, e);
         promise.reject(e);
         this._dcCreationPromise.delete(dcId);
-        return this._getOtherDc(dcId);
+        throw e;
       }
     }
     return this._dcConnections.get(dcId);
@@ -327,9 +338,15 @@ class NetworkManager {
    * @param defaultDcs  Default DCs to connect to
    */
   async connect(defaultDcs) {
+    if (this._destroyed) {
+      throw new MtcuteError("Network manager is destroyed");
+    }
     if (defaultDcs.main.id !== defaultDcs.media.id) {
       throw new MtArgumentError("Default DCs must be the same");
     }
+    if (this._teardownAbort.signal.aborted) {
+      this._teardownAbort = new AbortController();
+    }
     if (this._dcConnections.has(defaultDcs.main.id)) {
       throw new MtArgumentError("DC manager already exists");
     }
@@ -368,11 +385,12 @@ class NetworkManager {
       }
       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;
+    } finally {
+      this._pendingExports.delete(manager.dcId);
     }
   }
   setIsPremium(isPremium) {
@@ -442,6 +460,9 @@ class NetworkManager {
     }
   }
   async changePrimaryDc(newDc) {
+    if (this._destroyed) {
+      throw new MtcuteError("Network manager is destroyed");
+    }
     if (newDc === this._primaryDc?.dcId) return;
     const options = await this._findDcOptions(newDc);
     if (!this._dcConnections.has(newDc)) {
@@ -574,13 +595,20 @@ class NetworkManager {
     if (!this._primaryDc) throw new MtcuteError("Not connected to any DC");
     return this._primaryDc.dcId;
   }
-  async destroy() {
+  async disconnect() {
+    this._teardownAbort.abort();
+    this._primaryDc = void 0;
     for (const dc of this._dcConnections.values()) {
       await dc.destroy();
     }
     this._dcConnections.clear();
-    this.config.onUpdated.remove(this._onConfigChanged);
     this._resetOnNetworkChange?.();
+    this._resetOnNetworkChange = void 0;
+  }
+  async destroy() {
+    this._destroyed = true;
+    await this.disconnect();
+    this.config.onUpdated.remove(this._onConfigChanged);
   }
   getMtprotoMessageId() {
     return this._primaryDc.main._connections[0]._session.getMessageId();

package/network/network-manager.test.d.cts

@@ -0,0 +1 @@
+export {};