@mtcute/core 0.17.1 → 0.18.0

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.cts

@@ -0,0 +1,127 @@
+import { mtp, tl } from '@mtcute/tl';
+import { TlBinaryWriter, TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+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: Deferred<unknown>;
+    stack?: string;
+    gzipOverhead?: number;
+    chainId?: string | number;
+    invokeAfter?: Long;
+    sent?: boolean;
+    done?: boolean;
+    msgId?: Long;
+    seqNo?: number;
+    containerId?: Long;
+    acked?: boolean;
+    initConn?: boolean;
+    getState?: number;
+    cancelled?: boolean;
+    timeout?: timers.Timer;
+    resetAbortSignal?: () => void;
+}
+export type PendingMessage = {
+    _: 'rpc';
+    rpc: PendingRpc;
+} | {
+    _: 'container';
+    msgIds: Long[];
+} | {
+    _: 'state';
+    msgIds: Long[];
+    containerId: Long;
+} | {
+    _: 'resend';
+    msgIds: Long[];
+    containerId: Long;
+} | {
+    _: 'ping';
+    pingId: Long;
+    containerId: Long;
+} | {
+    _: 'destroy_session';
+    sessionId: Long;
+    containerId: Long;
+} | {
+    _: 'cancel';
+    msgId: Long;
+    containerId: Long;
+} | {
+    _: 'future_salts';
+    containerId: Long;
+} | {
+    _: 'bind';
+    promise: Deferred<boolean | mtp.RawMt_rpc_error>;
+};
+/**
+ * Class encapsulating a single MTProto session and storing
+ * all the relevant state
+ */
+export declare class MtprotoSession {
+    readonly _crypto: ICryptoProvider;
+    readonly log: Logger;
+    readonly _readerMap: TlReaderMap;
+    readonly _writerMap: TlWriterMap;
+    readonly _salts: ServerSaltManager;
+    _sessionId: Long;
+    _authKey: AuthKey;
+    _authKeyTemp: AuthKey;
+    _authKeyTempSecondary: AuthKey;
+    _timeOffset: number;
+    _lastMessageId: Long;
+    _seqNo: number;
+    recentOutgoingMsgIds: LruSet<Long>;
+    recentIncomingMsgIds: LruSet<Long>;
+    queuedRpc: Deque<PendingRpc>;
+    queuedAcks: Long[];
+    queuedStateReq: Long[];
+    queuedResendReq: Long[];
+    queuedCancelReq: Long[];
+    getStateSchedule: SortedArray<PendingRpc>;
+    chains: Map<string | number, Long>;
+    chainsPendingFails: Map<string | number, SortedArray<PendingRpc>>;
+    pendingMessages: LongMap<PendingMessage>;
+    destroySessionIdToMsgId: LongMap<Long>;
+    lastPingRtt: number;
+    lastPingTime: number;
+    lastPingMsgId: Long;
+    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;
+    /**
+     * Reset session by resetting auth key(s) and session state
+     */
+    reset(withAuthKey?: boolean): void;
+    resetAuthKey(): void;
+    updateTimeOffset(offset: number): void;
+    /**
+     * 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?: boolean): void;
+    enqueueRpc(rpc: PendingRpc, force?: boolean): boolean;
+    getMessageId(): Long;
+    getSeqNo(isContentRelated?: boolean): number;
+    /** Encrypt a single MTProto message using session's keys */
+    encryptMessage(message: Uint8Array): Uint8Array;
+    /** 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): number | undefined;
+    resetLastPing(withTime?: boolean): 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

@@ -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

package/network/mtproto-session.js

@@ -0,0 +1,239 @@
+import { LruSet, Deque, timers } from "@fuman/utils";
+import { TlSerializationCounter } from "@mtcute/tl-runtime";
+import Long from "long";
+import { randomLong, LongSet, LongMap, compareLongs } from "../utils/long-utils.js";
+import { getRandomInt } from "../utils/misc-utils.js";
+import { SortedArray } from "../utils/sorted-array.js";
+import { AuthKey } from "./auth-key.js";
+import { MtcuteError } from "../types/errors.js";
+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(_crypto, log, _readerMap);
+    this._authKeyTemp = new AuthKey(_crypto, log, _readerMap);
+    this._authKeyTempSecondary = new AuthKey(_crypto, log, _readerMap);
+  }
+  _sessionId = randomLong();
+  _authKey;
+  _authKeyTemp;
+  _authKeyTempSecondary;
+  _timeOffset = 0;
+  _lastMessageId = Long.ZERO;
+  _seqNo = 0;
+  /// state ///
+  // recent msg ids
+  recentOutgoingMsgIds = new LruSet(1e3, LongSet);
+  recentIncomingMsgIds = new LruSet(1e3, LongSet);
+  // queues
+  queuedRpc = new Deque();
+  queuedAcks = [];
+  queuedStateReq = [];
+  queuedResendReq = [];
+  queuedCancelReq = [];
+  getStateSchedule = new SortedArray([], (a, b) => a.getState - b.getState);
+  chains = /* @__PURE__ */ new Map();
+  chainsPendingFails = /* @__PURE__ */ new Map();
+  // requests info
+  pendingMessages = new LongMap();
+  destroySessionIdToMsgId = new 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();
+    }
+    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 = 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 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 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 = 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 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 : 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);
+    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);
+    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([], (a, b) => compareLongs(a.invokeAfter, b.invokeAfter));
+      this.chainsPendingFails.set(chainId, arr);
+    }
+    return arr;
+  }
+}
+export {
+  MtprotoSession
+};