@mtcute/core 0.17.0 → 0.18.0-rc.5

package/network/middlewares/flood-waiter.cjs

@@ -0,0 +1,70 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const abortSignal = require("../../utils/abort-signal.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const typeAssertions = require("../../utils/type-assertions.cjs");
+function floodWaiter(options) {
+  const { maxWait = 1e4, maxRetries = 5, store = true, minStoredWait = 3e3 } = options;
+  const storage = /* @__PURE__ */ new Map();
+  return async (ctx, next) => {
+    const method = ctx.request._;
+    const storedWaitUntil = store ? storage.get(method) : void 0;
+    const floodSleepThreshold = ctx.params?.floodSleepThreshold ?? maxWait;
+    if (storedWaitUntil !== void 0) {
+      const delta = storedWaitUntil - Date.now();
+      if (delta <= minStoredWait) {
+        storage.delete(method);
+      } else if (delta <= floodSleepThreshold) {
+        await miscUtils.sleepWithAbort(delta, abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal));
+        storage.delete(method);
+      } else {
+        return {
+          _: "mt_rpc_error",
+          errorCode: 420,
+          errorMessage: `FLOOD_WAIT_${Math.ceil(delta / 1e3)}`
+        };
+      }
+    }
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+      const res = await next(ctx);
+      if (!typeAssertions.isTlRpcError(res)) {
+        return res;
+      }
+      lastError = res;
+      const err = res.errorMessage;
+      if (err.startsWith("FLOOD_WAIT_") || err.startsWith("SLOWMODE_WAIT_") || err.startsWith("FLOOD_TEST_PHONE_WAIT_") || err.startsWith("FLOOD_PREMIUM_WAIT_")) {
+        let seconds = Number(err.slice(err.lastIndexOf("_") + 1));
+        if (Number.isNaN(seconds)) {
+          ctx.manager._log.warn("invalid flood wait error received: %s, ignoring", err);
+          return res;
+        }
+        if (store && !err.startsWith("SLOWMODE_WAIT_")) {
+          storage.set(method, Date.now() + seconds * 1e3);
+        }
+        if (seconds === 0) {
+          seconds = 1;
+        }
+        const ms = seconds * 1e3;
+        if (ms <= floodSleepThreshold) {
+          if (ctx.request._ !== "upload.getFile") {
+            ctx.manager._log.warn("%s resulted in a flood wait, will retry in %d seconds", method, seconds);
+          }
+          await miscUtils.sleepWithAbort(
+            ms,
+            abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+          );
+          continue;
+        }
+      }
+      return res;
+    }
+    return lastError;
+  };
+}
+exports.floodWaiter = floodWaiter;

package/network/middlewares/flood-waiter.js

@@ -0,0 +1,65 @@
+import { combineAbortSignals } from "../../utils/abort-signal.js";
+import { sleepWithAbort } from "../../utils/misc-utils.js";
+import { isTlRpcError } from "../../utils/type-assertions.js";
+function floodWaiter(options) {
+  const { maxWait = 1e4, maxRetries = 5, store = true, minStoredWait = 3e3 } = options;
+  const storage = /* @__PURE__ */ new Map();
+  return async (ctx, next) => {
+    const method = ctx.request._;
+    const storedWaitUntil = store ? storage.get(method) : void 0;
+    const floodSleepThreshold = ctx.params?.floodSleepThreshold ?? maxWait;
+    if (storedWaitUntil !== void 0) {
+      const delta = storedWaitUntil - Date.now();
+      if (delta <= minStoredWait) {
+        storage.delete(method);
+      } else if (delta <= floodSleepThreshold) {
+        await sleepWithAbort(delta, combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal));
+        storage.delete(method);
+      } else {
+        return {
+          _: "mt_rpc_error",
+          errorCode: 420,
+          errorMessage: `FLOOD_WAIT_${Math.ceil(delta / 1e3)}`
+        };
+      }
+    }
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+      const res = await next(ctx);
+      if (!isTlRpcError(res)) {
+        return res;
+      }
+      lastError = res;
+      const err = res.errorMessage;
+      if (err.startsWith("FLOOD_WAIT_") || err.startsWith("SLOWMODE_WAIT_") || err.startsWith("FLOOD_TEST_PHONE_WAIT_") || err.startsWith("FLOOD_PREMIUM_WAIT_")) {
+        let seconds = Number(err.slice(err.lastIndexOf("_") + 1));
+        if (Number.isNaN(seconds)) {
+          ctx.manager._log.warn("invalid flood wait error received: %s, ignoring", err);
+          return res;
+        }
+        if (store && !err.startsWith("SLOWMODE_WAIT_")) {
+          storage.set(method, Date.now() + seconds * 1e3);
+        }
+        if (seconds === 0) {
+          seconds = 1;
+        }
+        const ms = seconds * 1e3;
+        if (ms <= floodSleepThreshold) {
+          if (ctx.request._ !== "upload.getFile") {
+            ctx.manager._log.warn("%s resulted in a flood wait, will retry in %d seconds", method, seconds);
+          }
+          await sleepWithAbort(
+            ms,
+            combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+          );
+          continue;
+        }
+      }
+      return res;
+    }
+    return lastError;
+  };
+}
+export {
+  floodWaiter
+};

package/network/middlewares/internal-errors.cjs

@@ -0,0 +1,52 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tl = require("@mtcute/tl");
+const errors = require("../../types/errors.cjs");
+const abortSignal = require("../../utils/abort-signal.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const typeAssertions = require("../../utils/type-assertions.cjs");
+const CLIENT_ERRORS = /* @__PURE__ */ new Set([
+  tl.tl.RpcError.BAD_REQUEST,
+  tl.tl.RpcError.UNAUTHORIZED,
+  tl.tl.RpcError.FORBIDDEN,
+  tl.tl.RpcError.NOT_FOUND,
+  tl.tl.RpcError.FLOOD,
+  tl.tl.RpcError.SEE_OTHER,
+  tl.tl.RpcError.NOT_ACCEPTABLE
+]);
+function internalErrorsHandler(params) {
+  const { maxRetries = Infinity, waitTime = 1 } = params;
+  return async (ctx, next) => {
+    const numRetries = ctx.params?.maxRetryCount ?? maxRetries;
+    for (let i = 0; i <= numRetries; i++) {
+      const res = await next(ctx);
+      if (!typeAssertions.isTlRpcError(res)) return res;
+      if (!CLIENT_ERRORS.has(res.errorCode)) {
+        if (ctx.params?.throw503 && res.errorCode === -503) {
+          throw new errors.MtTimeoutError();
+        }
+        const waitSeconds = res.errorMessage === "WORKER_BUSY_TOO_LONG_RETRY" ? Math.max(1, waitTime) : waitTime;
+        ctx.manager._log.warn(
+          "Telegram is having internal issues: %d:%s, retrying in %ds",
+          res.errorCode,
+          res.errorMessage,
+          waitSeconds
+        );
+        if (waitSeconds > 0) {
+          await miscUtils.sleepWithAbort(
+            waitSeconds * 1e3,
+            abortSignal.combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+          );
+        }
+        continue;
+      }
+      return res;
+    }
+  };
+}
+exports.internalErrorsHandler = internalErrorsHandler;

package/network/middlewares/internal-errors.js

@@ -0,0 +1,47 @@
+import { tl } from "@mtcute/tl";
+import { MtTimeoutError } from "../../types/errors.js";
+import { combineAbortSignals } from "../../utils/abort-signal.js";
+import { sleepWithAbort } from "../../utils/misc-utils.js";
+import { isTlRpcError } from "../../utils/type-assertions.js";
+const CLIENT_ERRORS = /* @__PURE__ */ new Set([
+  tl.RpcError.BAD_REQUEST,
+  tl.RpcError.UNAUTHORIZED,
+  tl.RpcError.FORBIDDEN,
+  tl.RpcError.NOT_FOUND,
+  tl.RpcError.FLOOD,
+  tl.RpcError.SEE_OTHER,
+  tl.RpcError.NOT_ACCEPTABLE
+]);
+function internalErrorsHandler(params) {
+  const { maxRetries = Infinity, waitTime = 1 } = params;
+  return async (ctx, next) => {
+    const numRetries = ctx.params?.maxRetryCount ?? maxRetries;
+    for (let i = 0; i <= numRetries; i++) {
+      const res = await next(ctx);
+      if (!isTlRpcError(res)) return res;
+      if (!CLIENT_ERRORS.has(res.errorCode)) {
+        if (ctx.params?.throw503 && res.errorCode === -503) {
+          throw new MtTimeoutError();
+        }
+        const waitSeconds = res.errorMessage === "WORKER_BUSY_TOO_LONG_RETRY" ? Math.max(1, waitTime) : waitTime;
+        ctx.manager._log.warn(
+          "Telegram is having internal issues: %d:%s, retrying in %ds",
+          res.errorCode,
+          res.errorMessage,
+          waitSeconds
+        );
+        if (waitSeconds > 0) {
+          await sleepWithAbort(
+            waitSeconds * 1e3,
+            combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal)
+          );
+        }
+        continue;
+      }
+      return res;
+    }
+  };
+}
+export {
+  internalErrorsHandler
+};

package/network/middlewares/on-error.cjs

@@ -0,0 +1,21 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const typeAssertions = require("../../utils/type-assertions.cjs");
+function onRpcError(handler) {
+  return async (ctx, next) => {
+    let res = await next(ctx);
+    if (typeAssertions.isTlRpcError(res)) {
+      const handlerRes = await handler(ctx, res);
+      if (handlerRes !== void 0) {
+        res = handlerRes;
+      }
+    }
+    return res;
+  };
+}
+exports.onRpcError = onRpcError;

package/network/middlewares/on-error.js

@@ -0,0 +1,16 @@
+import { isTlRpcError } from "../../utils/type-assertions.js";
+function onRpcError(handler) {
+  return async (ctx, next) => {
+    let res = await next(ctx);
+    if (isTlRpcError(res)) {
+      const handlerRes = await handler(ctx, res);
+      if (handlerRes !== void 0) {
+        res = handlerRes;
+      }
+    }
+    return res;
+  };
+}
+export {
+  onRpcError
+};

package/network/middlewares/on-method.cjs

@@ -0,0 +1,16 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function onMethod(method, middleware) {
+  return async (ctx, next) => {
+    if (ctx.request._ !== method) {
+      return next(ctx);
+    }
+    return middleware(ctx, next);
+  };
+}
+exports.onMethod = onMethod;

package/network/middlewares/on-method.d.ts

@@ -1,5 +1,5 @@
+import { Middleware } from '@fuman/utils';
 import { tl } from '@mtcute/tl';
-import { Middleware } from '../../utils/composer.js';
 import { RpcCallMiddleware, RpcCallMiddlewareContext } from '../network-manager.js';
 /**
  * Middleware that will call `handler` whenever `method` RPC method is called.

package/network/middlewares/on-method.js

@@ -0,0 +1,11 @@
+function onMethod(method, middleware) {
+  return async (ctx, next) => {
+    if (ctx.request._ !== method) {
+      return next(ctx);
+    }
+    return middleware(ctx, next);
+  };
+}
+export {
+  onMethod
+};

package/network/mtproto-session.cjs

@@ -0,0 +1,244 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] 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");
+const tlRuntime = require("@mtcute/tl-runtime");
+const Long = require("long");
+const longUtils = require("../utils/long-utils.cjs");
+const miscUtils = require("../utils/misc-utils.cjs");
+const sortedArray = require("../utils/sorted-array.cjs");
+const authKey = require("./auth-key.cjs");
+const errors = require("../types/errors.cjs");
+class MtprotoSession {
+  constructor(_crypto, log, _readerMap, _writerMap, _salts) {
+    this._crypto = _crypto;
+    this.log = log;
+    this._readerMap = _readerMap;
+    this._writerMap = _writerMap;
+    this._salts = _salts;
+    this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    this._authKey = new authKey.AuthKey(_crypto, log, _readerMap);
+    this._authKeyTemp = new authKey.AuthKey(_crypto, log, _readerMap);
+    this._authKeyTempSecondary = new authKey.AuthKey(_crypto, log, _readerMap);
+  }
+  _sessionId = longUtils.randomLong();
+  _authKey;
+  _authKeyTemp;
+  _authKeyTempSecondary;
+  _timeOffset = 0;
+  _lastMessageId = Long.ZERO;
+  _seqNo = 0;
+  /// state ///
+  // recent msg ids
+  recentOutgoingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
+  recentIncomingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
+  // queues
+  queuedRpc = new utils.Deque();
+  queuedAcks = [];
+  queuedStateReq = [];
+  queuedResendReq = [];
+  queuedCancelReq = [];
+  getStateSchedule = new sortedArray.SortedArray([], (a, b) => a.getState - b.getState);
+  chains = /* @__PURE__ */ new Map();
+  chainsPendingFails = /* @__PURE__ */ new Map();
+  // requests info
+  pendingMessages = new longUtils.LongMap();
+  destroySessionIdToMsgId = new longUtils.LongMap();
+  lastPingRtt = Number.NaN;
+  lastPingTime = 0;
+  lastPingMsgId = Long.ZERO;
+  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
+    );
+  }
+  /**
+   * Reset session by resetting auth key(s) and session state
+   */
+  reset(withAuthKey = false) {
+    if (withAuthKey) {
+      this.resetAuthKey();
+    }
+    utils.timers.clearTimeout(this.current429Timeout);
+    this.resetState(withAuthKey);
+  }
+  resetAuthKey() {
+    this._authKey.reset();
+    this._authKeyTemp.reset();
+    this._authKeyTempSecondary.reset();
+  }
+  updateTimeOffset(offset) {
+    this.log.debug("time offset updated: %d", offset);
+    this._timeOffset = offset;
+    this._lastMessageId = Long.ZERO;
+  }
+  /**
+   * Reset session state and generate a new session ID.
+   *
+   * By default, also cancels any pending RPC requests.
+   * If `keepPending` is set to `true`, pending requests will be kept
+   */
+  resetState(keepPending = false) {
+    this._lastMessageId = Long.ZERO;
+    this._seqNo = 0;
+    this._sessionId = longUtils.randomLong();
+    this.log.debug("session reset, new sid = %h", this._sessionId);
+    this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    if (!keepPending) {
+      for (const info of this.pendingMessages.values()) {
+        if (info._ === "rpc") {
+          this.log.debug("rejecting pending rpc %s", info.rpc.method);
+          info.rpc.promise.reject(new errors.MtcuteError("Session is reset"));
+        }
+      }
+      this.pendingMessages.clear();
+    }
+    this.recentOutgoingMsgIds.clear();
+    this.recentIncomingMsgIds.clear();
+    if (!keepPending) {
+      while (this.queuedRpc.length) {
+        const rpc = this.queuedRpc.popFront();
+        if (rpc.sent === false) {
+          this.log.debug("rejecting pending rpc %s", rpc.method);
+          rpc.promise.reject(new errors.MtcuteError("Session is reset"));
+        }
+      }
+    }
+    this.queuedAcks.length = 0;
+    this.queuedStateReq.length = 0;
+    this.queuedResendReq.length = 0;
+    this.queuedCancelReq.length = 0;
+    this.getStateSchedule.clear();
+    this.chains.clear();
+    this.chainsPendingFails.clear();
+    this.resetLastPing(true);
+  }
+  enqueueRpc(rpc, force) {
+    if (!force && !rpc.sent || rpc.cancelled) return false;
+    rpc.sent = false;
+    rpc.containerId = void 0;
+    this.log.debug("enqueued %s for sending (msg_id = %s)", rpc.method, rpc.msgId || "n/a");
+    this.queuedRpc.pushBack(rpc);
+    return true;
+  }
+  getMessageId() {
+    const timeTicks = Date.now();
+    const timeSec = Math.floor(timeTicks / 1e3) - this._timeOffset;
+    const timeMSec = timeTicks % 1e3;
+    const random = miscUtils.getRandomInt(65535);
+    let messageId = new Long(timeMSec << 21 | random << 3 | 4, timeSec);
+    if (this._lastMessageId.ge(messageId)) {
+      messageId = this._lastMessageId.add(4);
+    }
+    this._lastMessageId = messageId;
+    return messageId;
+  }
+  getSeqNo(isContentRelated = true) {
+    let seqNo = this._seqNo;
+    if (isContentRelated) {
+      seqNo += 1;
+      this._seqNo += 2;
+    }
+    return seqNo;
+  }
+  /** Encrypt a single MTProto message using session's keys */
+  encryptMessage(message) {
+    const key = this._authKeyTemp.ready ? this._authKeyTemp : this._authKey;
+    return key.encryptMessage(message, this._salts.currentSalt, this._sessionId);
+  }
+  /** Decrypt a single MTProto message using session's keys */
+  decryptMessage(data, callback) {
+    if (!this._authKey.ready) throw new errors.MtcuteError("Keys are not set up!");
+    const authKeyId = data.subarray(0, 8);
+    let key;
+    if (this._authKey.match(authKeyId)) {
+      key = this._authKey;
+    } else if (this._authKeyTemp.match(authKeyId)) {
+      key = this._authKeyTemp;
+    } else if (this._authKeyTempSecondary.match(authKeyId)) {
+      key = this._authKeyTempSecondary;
+    } else {
+      this.log.warn(
+        "received message with unknown authKey = %h (expected %h or %h or %h)",
+        authKeyId,
+        this._authKey.id,
+        this._authKeyTemp.id,
+        this._authKeyTempSecondary.id
+      );
+      return;
+    }
+    return key.decryptMessage(data, this._sessionId, callback);
+  }
+  writeMessage(writer, content, isContentRelated = true) {
+    const messageId = this.getMessageId();
+    const seqNo = this.getSeqNo(isContentRelated);
+    const length = ArrayBuffer.isView(content) ? content.length : tlRuntime.TlSerializationCounter.countNeededBytes(writer.objectMap, content);
+    writer.long(messageId);
+    writer.int(seqNo);
+    writer.uint(length);
+    if (ArrayBuffer.isView(content)) writer.raw(content);
+    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);
+    return Date.now() + timeout;
+  }
+  resetLastPing(withTime = false) {
+    if (withTime) this.lastPingTime = 0;
+    if (!this.lastPingMsgId.isZero()) {
+      this.pendingMessages.delete(this.lastPingMsgId);
+    }
+    this.lastPingMsgId = Long.ZERO;
+  }
+  addToChain(chainId, msgId) {
+    const prevMsgId = this.chains.get(chainId);
+    this.chains.set(chainId, msgId);
+    this.log.debug("added message %l to chain %s (prev: %l)", msgId, chainId, prevMsgId);
+    return prevMsgId;
+  }
+  removeFromChain(chainId, msgId) {
+    const lastMsgId = this.chains.get(chainId);
+    if (!lastMsgId) {
+      this.log.warn("tried to remove message %l from empty chain %s", msgId, chainId);
+      return;
+    }
+    if (lastMsgId.eq(msgId)) {
+      this.log.debug("chain %s: exhausted, last message %l", chainId, msgId);
+      this.chains.delete(chainId);
+    }
+  }
+  getPendingChainedFails(chainId) {
+    let arr = this.chainsPendingFails.get(chainId);
+    if (!arr) {
+      arr = new sortedArray.SortedArray([], (a, b) => longUtils.compareLongs(a.invokeAfter, b.invokeAfter));
+      this.chainsPendingFails.set(chainId, arr);
+    }
+    return arr;
+  }
+}
+exports.MtprotoSession = MtprotoSession;

package/network/mtproto-session.d.ts

@@ -1,13 +1,14 @@
-import { default as Long } from 'long';
 import { mtp, tl } from '@mtcute/tl';
 import { TlBinaryWriter, TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
-import { ControllablePromise, ICryptoProvider, Logger, Deque, LongMap, LruSet, SortedArray, timers } from '../utils/index.js';
-import { AuthKey } from './auth-key.js';
+import { ICryptoProvider, Logger, LongMap, SortedArray } from '../utils/index.js';
 import { ServerSaltManager } from './server-salt.js';
+import { Deferred, Deque, LruSet, timers } from '@fuman/utils';
+import { default as Long } from 'long';
+import { AuthKey } from './auth-key.js';
 export interface PendingRpc {
     method: string;
     data: Uint8Array;
-    promise: ControllablePromise;
+    promise: Deferred<unknown>;
     stack?: string;
     gzipOverhead?: number;
     chainId?: string | number;
@@ -22,6 +23,7 @@ export interface PendingRpc {
     getState?: number;
     cancelled?: boolean;
     timeout?: timers.Timer;
+    resetAbortSignal?: () => void;
 }
 export type PendingMessage = {
     _: 'rpc';
@@ -54,7 +56,7 @@ export type PendingMessage = {
     containerId: Long;
 } | {
     _: 'bind';
-    promise: ControllablePromise<boolean | mtp.RawMt_rpc_error>;
+    promise: Deferred<boolean | mtp.RawMt_rpc_error>;
 };
 /**
  * Class encapsulating a single MTProto session and storing