@mtcute/core 0.29.7 → 0.30.0

package/network/flood-control.cjs

@@ -0,0 +1,149 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] 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");
+class FloodControl {
+  _rules;
+  _maxWindow;
+  _events = [];
+  constructor(rules) {
+    if (rules.length === 0) throw new Error("FloodControl needs at least one rule");
+    this._rules = rules;
+    this._maxWindow = rules.reduce((m, r) => Math.max(m, r.windowMs), 0);
+  }
+  /** Earliest absolute perf-now ms at which a new event is permitted. */
+  getWakeupAt(now) {
+    let wakeup = 0;
+    for (const { count, windowMs } of this._rules) {
+      const cutoff = now - windowMs;
+      let inWindow = 0;
+      let oldestInWindowIdx = -1;
+      for (let i = this._events.length - 1; i >= 0; i--) {
+        if (this._events[i] <= cutoff) break;
+        inWindow++;
+        oldestInWindowIdx = i;
+      }
+      if (inWindow >= count) {
+        const t = this._events[oldestInWindowIdx] + windowMs;
+        if (t > wakeup) wakeup = t;
+      }
+    }
+    return wakeup;
+  }
+  addEvent(now) {
+    this._events.push(now);
+    this._prune(now);
+  }
+  _prune(now) {
+    const cutoff = now - this._maxWindow;
+    let i = 0;
+    while (i < this._events.length && this._events[i] < cutoff) i++;
+    if (i > 0) this._events.splice(0, i);
+  }
+  reset() {
+    this._events = [];
+  }
+}
+const DEFAULT_SANITY_LIMITS = [
+  { count: 5, windowMs: 1e4 }
+];
+const DEFAULT_FLOOD_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+const DEFAULT_MTPROTO_ERROR_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+class ConnectionFloodController {
+  sanity;
+  flood;
+  mtprotoError;
+  _log;
+  constructor(limits = {}) {
+    this.sanity = new FloodControl(limits.sanity ?? DEFAULT_SANITY_LIMITS);
+    this.flood = new FloodControl(limits.flood ?? DEFAULT_FLOOD_LIMITS);
+    this.mtprotoError = new FloodControl(limits.mtprotoError ?? DEFAULT_MTPROTO_ERROR_LIMITS);
+  }
+  setLogger(log) {
+    this._log = log;
+  }
+  /**
+   * Notify a network-up transition.
+   *
+   * TDLib clears sanity + online-regime flood + backoff on
+   * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+   * and our transport layer owns its own reconnect backoff, so only the
+   * sanity limiter is reset here.
+   */
+  notifyNetworkUp() {
+    this._log?.debug("network up, resetting sanity limiter");
+    this.sanity.reset();
+  }
+  /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+  addMtprotoError(now = performance.now()) {
+    this._log?.debug("recording mtproto error");
+    this.mtprotoError.addEvent(now);
+  }
+  /** Earliest perf-now ms at which a new connection attempt is permitted. */
+  getWakeupAt(now) {
+    return Math.max(
+      this.sanity.getWakeupAt(now),
+      this.flood.getWakeupAt(now),
+      this.mtprotoError.getWakeupAt(now)
+    );
+  }
+  /**
+   * Block until a connection attempt is permitted under all applicable
+   * limiters, then record the attempt. Concurrent waiters serialize fairly
+   * because the first to wake records its event before the next checks state.
+   *
+   * If `signal` aborts, the pending timer is cleared and the promise rejects
+   * with the signal's reason.
+   */
+  async wait(signal) {
+    let waited = false;
+    while (true) {
+      signal?.throwIfAborted();
+      const now = performance.now();
+      const wakeup = this.getWakeupAt(now);
+      if (wakeup <= now) {
+        this.sanity.addEvent(now);
+        this.flood.addEvent(now);
+        if (waited) this._log?.debug("admitted connect after waiting");
+        return;
+      }
+      const delay = wakeup - now;
+      this._log?.debug("connect throttled (waiting %dms)", Math.round(delay));
+      waited = true;
+      await new Promise((resolve, reject) => {
+        const handle = utils.timers.setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
+        const onAbort = () => {
+          utils.timers.clearTimeout(handle);
+          reject(signal.reason);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+  }
+  /** Reset all internal state. Mainly for tests. */
+  reset() {
+    this.sanity.reset();
+    this.flood.reset();
+    this.mtprotoError.reset();
+  }
+}
+exports.ConnectionFloodController = ConnectionFloodController;
+exports.DEFAULT_FLOOD_LIMITS = DEFAULT_FLOOD_LIMITS;
+exports.DEFAULT_MTPROTO_ERROR_LIMITS = DEFAULT_MTPROTO_ERROR_LIMITS;
+exports.DEFAULT_SANITY_LIMITS = DEFAULT_SANITY_LIMITS;
+exports.FloodControl = FloodControl;

package/network/flood-control.d.cts

@@ -0,0 +1,79 @@
+import { Logger } from '../utils/logger.js';
+export interface FloodLimit {
+    /** maximum events allowed within `windowMs` */
+    count: number;
+    /** window size in ms */
+    windowMs: number;
+}
+/**
+ * Sliding-window flood control. Port of TDLib's `FloodControlStrict`
+ * (tdutils/td/utils/FloodControlStrict.h).
+ */
+export declare class FloodControl {
+    private readonly _rules;
+    private readonly _maxWindow;
+    private _events;
+    constructor(rules: readonly FloodLimit[]);
+    /** Earliest absolute perf-now ms at which a new event is permitted. */
+    getWakeupAt(now: number): number;
+    addEvent(now: number): void;
+    private _prune;
+    reset(): void;
+}
+export declare const DEFAULT_SANITY_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_FLOOD_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_MTPROTO_ERROR_LIMITS: readonly FloodLimit[];
+export interface ConnectionFloodLimits {
+    sanity?: readonly FloodLimit[];
+    flood?: readonly FloodLimit[];
+    mtprotoError?: readonly FloodLimit[];
+}
+/**
+ * Per-connection-slot flood control bundle modeled after TDLib's
+ * `ConnectionCreator` client state (`ConnectionCreator.cpp`) — TDLib keys
+ * its flood control by pool slot (the `SessionProxy#i` hash), so each
+ * socket's connect history is throttled independently.
+ *
+ * Three limiters compose:
+ *  - `sanity` — absolute ceiling, always applied
+ *  - `flood` — burst limit on connection attempts, always applied
+ *  - `mtprotoError` — ticks only on MTProto-level errors, always applied
+ *
+ * TDLib additionally has a stricter "online" regime keyed to app foreground
+ * state — we have no such signal, so only the permissive regime is modeled.
+ *
+ * `wait()` blocks until all limiters allow a fresh connection and records
+ * the event atomically (sanity + flood).
+ */
+export declare class ConnectionFloodController {
+    readonly sanity: FloodControl;
+    readonly flood: FloodControl;
+    readonly mtprotoError: FloodControl;
+    private _log?;
+    constructor(limits?: ConnectionFloodLimits);
+    setLogger(log: Logger): void;
+    /**
+     * Notify a network-up transition.
+     *
+     * TDLib clears sanity + online-regime flood + backoff on
+     * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+     * and our transport layer owns its own reconnect backoff, so only the
+     * sanity limiter is reset here.
+     */
+    notifyNetworkUp(): void;
+    /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+    addMtprotoError(now?: number): void;
+    /** Earliest perf-now ms at which a new connection attempt is permitted. */
+    getWakeupAt(now: number): number;
+    /**
+     * Block until a connection attempt is permitted under all applicable
+     * limiters, then record the attempt. Concurrent waiters serialize fairly
+     * because the first to wake records its event before the next checks state.
+     *
+     * If `signal` aborts, the pending timer is cleared and the promise rejects
+     * with the signal's reason.
+     */
+    wait(signal?: AbortSignal): Promise<void>;
+    /** Reset all internal state. Mainly for tests. */
+    reset(): void;
+}

package/network/flood-control.d.ts

@@ -0,0 +1,79 @@
+import { Logger } from '../utils/logger.js';
+export interface FloodLimit {
+    /** maximum events allowed within `windowMs` */
+    count: number;
+    /** window size in ms */
+    windowMs: number;
+}
+/**
+ * Sliding-window flood control. Port of TDLib's `FloodControlStrict`
+ * (tdutils/td/utils/FloodControlStrict.h).
+ */
+export declare class FloodControl {
+    private readonly _rules;
+    private readonly _maxWindow;
+    private _events;
+    constructor(rules: readonly FloodLimit[]);
+    /** Earliest absolute perf-now ms at which a new event is permitted. */
+    getWakeupAt(now: number): number;
+    addEvent(now: number): void;
+    private _prune;
+    reset(): void;
+}
+export declare const DEFAULT_SANITY_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_FLOOD_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_MTPROTO_ERROR_LIMITS: readonly FloodLimit[];
+export interface ConnectionFloodLimits {
+    sanity?: readonly FloodLimit[];
+    flood?: readonly FloodLimit[];
+    mtprotoError?: readonly FloodLimit[];
+}
+/**
+ * Per-connection-slot flood control bundle modeled after TDLib's
+ * `ConnectionCreator` client state (`ConnectionCreator.cpp`) — TDLib keys
+ * its flood control by pool slot (the `SessionProxy#i` hash), so each
+ * socket's connect history is throttled independently.
+ *
+ * Three limiters compose:
+ *  - `sanity` — absolute ceiling, always applied
+ *  - `flood` — burst limit on connection attempts, always applied
+ *  - `mtprotoError` — ticks only on MTProto-level errors, always applied
+ *
+ * TDLib additionally has a stricter "online" regime keyed to app foreground
+ * state — we have no such signal, so only the permissive regime is modeled.
+ *
+ * `wait()` blocks until all limiters allow a fresh connection and records
+ * the event atomically (sanity + flood).
+ */
+export declare class ConnectionFloodController {
+    readonly sanity: FloodControl;
+    readonly flood: FloodControl;
+    readonly mtprotoError: FloodControl;
+    private _log?;
+    constructor(limits?: ConnectionFloodLimits);
+    setLogger(log: Logger): void;
+    /**
+     * Notify a network-up transition.
+     *
+     * TDLib clears sanity + online-regime flood + backoff on
+     * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+     * and our transport layer owns its own reconnect backoff, so only the
+     * sanity limiter is reset here.
+     */
+    notifyNetworkUp(): void;
+    /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+    addMtprotoError(now?: number): void;
+    /** Earliest perf-now ms at which a new connection attempt is permitted. */
+    getWakeupAt(now: number): number;
+    /**
+     * Block until a connection attempt is permitted under all applicable
+     * limiters, then record the attempt. Concurrent waiters serialize fairly
+     * because the first to wake records its event before the next checks state.
+     *
+     * If `signal` aborts, the pending timer is cleared and the promise rejects
+     * with the signal's reason.
+     */
+    wait(signal?: AbortSignal): Promise<void>;
+    /** Reset all internal state. Mainly for tests. */
+    reset(): void;
+}

package/network/flood-control.js

@@ -0,0 +1,144 @@
+import { timers } from "@fuman/utils";
+class FloodControl {
+  _rules;
+  _maxWindow;
+  _events = [];
+  constructor(rules) {
+    if (rules.length === 0) throw new Error("FloodControl needs at least one rule");
+    this._rules = rules;
+    this._maxWindow = rules.reduce((m, r) => Math.max(m, r.windowMs), 0);
+  }
+  /** Earliest absolute perf-now ms at which a new event is permitted. */
+  getWakeupAt(now) {
+    let wakeup = 0;
+    for (const { count, windowMs } of this._rules) {
+      const cutoff = now - windowMs;
+      let inWindow = 0;
+      let oldestInWindowIdx = -1;
+      for (let i = this._events.length - 1; i >= 0; i--) {
+        if (this._events[i] <= cutoff) break;
+        inWindow++;
+        oldestInWindowIdx = i;
+      }
+      if (inWindow >= count) {
+        const t = this._events[oldestInWindowIdx] + windowMs;
+        if (t > wakeup) wakeup = t;
+      }
+    }
+    return wakeup;
+  }
+  addEvent(now) {
+    this._events.push(now);
+    this._prune(now);
+  }
+  _prune(now) {
+    const cutoff = now - this._maxWindow;
+    let i = 0;
+    while (i < this._events.length && this._events[i] < cutoff) i++;
+    if (i > 0) this._events.splice(0, i);
+  }
+  reset() {
+    this._events = [];
+  }
+}
+const DEFAULT_SANITY_LIMITS = [
+  { count: 5, windowMs: 1e4 }
+];
+const DEFAULT_FLOOD_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+const DEFAULT_MTPROTO_ERROR_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+class ConnectionFloodController {
+  sanity;
+  flood;
+  mtprotoError;
+  _log;
+  constructor(limits = {}) {
+    this.sanity = new FloodControl(limits.sanity ?? DEFAULT_SANITY_LIMITS);
+    this.flood = new FloodControl(limits.flood ?? DEFAULT_FLOOD_LIMITS);
+    this.mtprotoError = new FloodControl(limits.mtprotoError ?? DEFAULT_MTPROTO_ERROR_LIMITS);
+  }
+  setLogger(log) {
+    this._log = log;
+  }
+  /**
+   * Notify a network-up transition.
+   *
+   * TDLib clears sanity + online-regime flood + backoff on
+   * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+   * and our transport layer owns its own reconnect backoff, so only the
+   * sanity limiter is reset here.
+   */
+  notifyNetworkUp() {
+    this._log?.debug("network up, resetting sanity limiter");
+    this.sanity.reset();
+  }
+  /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+  addMtprotoError(now = performance.now()) {
+    this._log?.debug("recording mtproto error");
+    this.mtprotoError.addEvent(now);
+  }
+  /** Earliest perf-now ms at which a new connection attempt is permitted. */
+  getWakeupAt(now) {
+    return Math.max(
+      this.sanity.getWakeupAt(now),
+      this.flood.getWakeupAt(now),
+      this.mtprotoError.getWakeupAt(now)
+    );
+  }
+  /**
+   * Block until a connection attempt is permitted under all applicable
+   * limiters, then record the attempt. Concurrent waiters serialize fairly
+   * because the first to wake records its event before the next checks state.
+   *
+   * If `signal` aborts, the pending timer is cleared and the promise rejects
+   * with the signal's reason.
+   */
+  async wait(signal) {
+    let waited = false;
+    while (true) {
+      signal?.throwIfAborted();
+      const now = performance.now();
+      const wakeup = this.getWakeupAt(now);
+      if (wakeup <= now) {
+        this.sanity.addEvent(now);
+        this.flood.addEvent(now);
+        if (waited) this._log?.debug("admitted connect after waiting");
+        return;
+      }
+      const delay = wakeup - now;
+      this._log?.debug("connect throttled (waiting %dms)", Math.round(delay));
+      waited = true;
+      await new Promise((resolve, reject) => {
+        const handle = timers.setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
+        const onAbort = () => {
+          timers.clearTimeout(handle);
+          reject(signal.reason);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+  }
+  /** Reset all internal state. Mainly for tests. */
+  reset() {
+    this.sanity.reset();
+    this.flood.reset();
+    this.mtprotoError.reset();
+  }
+}
+export {
+  ConnectionFloodController,
+  DEFAULT_FLOOD_LIMITS,
+  DEFAULT_MTPROTO_ERROR_LIMITS,
+  DEFAULT_SANITY_LIMITS,
+  FloodControl
+};

package/network/flood-control.test.d.cts

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

package/network/flood-control.test.d.ts

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

package/network/mtproto-session.cjs

@@ -36,6 +36,7 @@ class MtprotoSession {
   // recent msg ids
   recentOutgoingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
   recentIncomingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
+  // <deno-tsignore>
   recentStateRequests = new utils.LruMap(1e3, longUtils.LongMap);
   // queues
   queuedRpc = new utils.Deque();
@@ -60,9 +61,6 @@ class MtprotoSession {
   lastSessionCreatedUid = Long.ZERO;
   initConnectionCalled = false;
   authorizationPending = false;
-  next429Timeout = 1e3;
-  current429Timeout;
-  next429ResetTimeout;
   get hasPendingMessages() {
     return Boolean(
       this.queuedRpc.length || this.queuedAcks.length || this.queuedStateReq.length || this.queuedResendReq.length || this.queuedCancelReq.length
@@ -75,7 +73,6 @@ class MtprotoSession {
     if (withAuthKey) {
       this.resetAuthKey();
     }
-    utils.timers.clearTimeout(this.current429Timeout);
     this.resetState(withAuthKey);
   }
   resetAuthKey() {
@@ -197,23 +194,6 @@ class MtprotoSession {
     else writer.object(content);
     return messageId;
   }
-  onTransportFlood(callback) {
-    if (this.current429Timeout) return;
-    this.resetLastPing(true);
-    const timeout = this.next429Timeout;
-    this.next429Timeout = Math.min(this.next429Timeout * 2, 32e3);
-    utils.timers.clearTimeout(this.current429Timeout);
-    utils.timers.clearTimeout(this.next429ResetTimeout);
-    this.current429Timeout = utils.timers.setTimeout(() => {
-      this.current429Timeout = void 0;
-      callback();
-    }, timeout);
-    this.next429ResetTimeout = utils.timers.setTimeout(() => {
-      this.next429ResetTimeout = void 0;
-      this.next429Timeout = 1e3;
-    }, 6e4);
-    this.log.debug("transport flood, waiting for %d ms before proceeding", timeout);
-  }
   resetLastPing(withTime = false) {
     if (withTime) this.lastPingTime = 0;
     if (!this.lastPingMsgId.isZero()) {

package/network/mtproto-session.d.cts

@@ -1,4 +1,4 @@
-import { Deferred, Deque, LruMap, LruSet, timers } from '@fuman/utils';
+import { Deferred, timers, Deque, LruMap, LruSet } from '@fuman/utils';
 import { TlBinaryWriter, TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
 import { mtp, tl } from '../tl/index.js';
 import { ICryptoProvider, Logger, LongMap, SortedArray } from '../utils/index.js';
@@ -94,9 +94,6 @@ export declare class MtprotoSession {
     lastSessionCreatedUid: Long;
     initConnectionCalled: boolean;
     authorizationPending: boolean;
-    next429Timeout: number;
-    current429Timeout?: timers.Timer;
-    next429ResetTimeout?: timers.Timer;
     constructor(_crypto: ICryptoProvider, log: Logger, _readerMap: TlReaderMap, _writerMap: TlWriterMap, _salts: ServerSaltManager);
     get hasPendingMessages(): boolean;
     /**
@@ -120,7 +117,6 @@ 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;
-    onTransportFlood(callback: () => void): void;
     resetLastPing(withTime?: boolean): void;
     addToChain(chainId: string | number, msgId: Long): Long | undefined;
     removeFromChain(chainId: string | number, msgId: Long): void;

package/network/mtproto-session.d.ts

@@ -1,4 +1,4 @@
-import { Deferred, Deque, LruMap, LruSet, timers } from '@fuman/utils';
+import { Deferred, timers, Deque, LruMap, LruSet } from '@fuman/utils';
 import { TlBinaryWriter, TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
 import { mtp, tl } from '../tl/index.js';
 import { ICryptoProvider, Logger, LongMap, SortedArray } from '../utils/index.js';
@@ -94,9 +94,6 @@ export declare class MtprotoSession {
     lastSessionCreatedUid: Long;
     initConnectionCalled: boolean;
     authorizationPending: boolean;
-    next429Timeout: number;
-    current429Timeout?: timers.Timer;
-    next429ResetTimeout?: timers.Timer;
     constructor(_crypto: ICryptoProvider, log: Logger, _readerMap: TlReaderMap, _writerMap: TlWriterMap, _salts: ServerSaltManager);
     get hasPendingMessages(): boolean;
     /**
@@ -120,7 +117,6 @@ 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;
-    onTransportFlood(callback: () => void): void;
     resetLastPing(withTime?: boolean): void;
     addToChain(chainId: string | number, msgId: Long): Long | undefined;
     removeFromChain(chainId: string | number, msgId: Long): void;

package/network/mtproto-session.js

@@ -1,4 +1,4 @@
-import { LruSet, LruMap, Deque, timers } from "@fuman/utils";
+import { LruSet, LruMap, Deque } from "@fuman/utils";
 import { TlSerializationCounter } from "@mtcute/tl-runtime";
 import Long from "long";
 import { randomLong, LongSet, LongMap, compareLongs } from "../utils/long-utils.js";
@@ -29,6 +29,7 @@ class MtprotoSession {
   // recent msg ids
   recentOutgoingMsgIds = new LruSet(1e3, LongSet);
   recentIncomingMsgIds = new LruSet(1e3, LongSet);
+  // <deno-tsignore>
   recentStateRequests = new LruMap(1e3, LongMap);
   // queues
   queuedRpc = new Deque();
@@ -53,9 +54,6 @@ class MtprotoSession {
   lastSessionCreatedUid = Long.ZERO;
   initConnectionCalled = false;
   authorizationPending = false;
-  next429Timeout = 1e3;
-  current429Timeout;
-  next429ResetTimeout;
   get hasPendingMessages() {
     return Boolean(
       this.queuedRpc.length || this.queuedAcks.length || this.queuedStateReq.length || this.queuedResendReq.length || this.queuedCancelReq.length
@@ -68,7 +66,6 @@ class MtprotoSession {
     if (withAuthKey) {
       this.resetAuthKey();
     }
-    timers.clearTimeout(this.current429Timeout);
     this.resetState(withAuthKey);
   }
   resetAuthKey() {
@@ -190,23 +187,6 @@ class MtprotoSession {
     else writer.object(content);
     return messageId;
   }
-  onTransportFlood(callback) {
-    if (this.current429Timeout) return;
-    this.resetLastPing(true);
-    const timeout = this.next429Timeout;
-    this.next429Timeout = Math.min(this.next429Timeout * 2, 32e3);
-    timers.clearTimeout(this.current429Timeout);
-    timers.clearTimeout(this.next429ResetTimeout);
-    this.current429Timeout = timers.setTimeout(() => {
-      this.current429Timeout = void 0;
-      callback();
-    }, timeout);
-    this.next429ResetTimeout = timers.setTimeout(() => {
-      this.next429ResetTimeout = void 0;
-      this.next429Timeout = 1e3;
-    }, 6e4);
-    this.log.debug("transport flood, waiting for %d ms before proceeding", timeout);
-  }
   resetLastPing(withTime = false) {
     if (withTime) this.lastPingTime = 0;
     if (!this.lastPingMsgId.isZero()) {

package/network/multi-session-connection.cjs

@@ -16,6 +16,24 @@ class MultiSessionConnection {
     this._enforcePfs = _count > 1 && params.isMainConnection;
     this._updateConnections();
   }
+  static _pickConnection(loads, ready) {
+    let min = Infinity;
+    let minIdx = 0;
+    let foundReady = false;
+    for (let i = 0; i < loads.length; i++) {
+      const isReady = ready[i];
+      if (foundReady && !isReady) continue;
+      if (isReady && !foundReady) {
+        foundReady = true;
+        min = Infinity;
+      }
+      if (loads[i] < min) {
+        min = loads[i];
+        minIdx = i;
+      }
+    }
+    return minIdx;
+  }
   _log;
   _enforcePfs = false;
   // NB: dont forget to update .reset()
@@ -103,10 +121,6 @@ class MultiSessionConnection {
       conn.onUsable.add(() => this.onUsable.emit(i));
       conn.onWait.add(() => this.onWait.emit(i));
       conn.onRequestAuth.add(() => this.onRequestAuth.emit(i));
-      conn.onFloodDone.add(() => {
-        this._log.debug("received flood-done from connection %d", i);
-        this._connections.forEach((it) => it.flushWhenIdle());
-      });
       this._connections.push(conn);
       if (this._authKey !== null) conn._session._authKey.setup(this._authKey);
       if (connect && !enforcePfsChanged) conn.connect();
@@ -127,19 +141,15 @@ class MultiSessionConnection {
     this.onRequestAuth.clear();
     this._destroyed = true;
   }
-  _nextConnection = 0;
   sendRpc(request, timeout, abortSignal, chainId) {
-    let min = Infinity;
-    let minIdx = 0;
-    for (let i = 0; i < this._connections.length; i++) {
-      const conn = this._connections[i];
-      const total = conn._session.queuedRpc.length + conn._session.pendingMessages.size;
-      if (total < min) {
-        min = total;
-        minIdx = i;
-      }
-    }
-    return this._connections[minIdx].sendRpc(request, timeout, abortSignal, chainId);
+    const loads = this._connections.map((c) => c._session.queuedRpc.length + c._session.pendingMessages.size);
+    const ready = this._connections.map((c) => c.isConnected);
+    return this._connections[MultiSessionConnection._pickConnection(loads, ready)].sendRpc(
+      request,
+      timeout,
+      abortSignal,
+      chainId
+    );
   }
   connect() {
     for (const conn of this._connections) {