@mtcute/core 0.17.1 → 0.18.0

package/network/session-connection.js

@@ -0,0 +1,1445 @@
+import { Emitter, timers, u8, Deferred } from "@fuman/utils";
+import { tl } from "@mtcute/tl";
+import { TlBinaryWriter, TlSerializationCounter, TlBinaryReader } from "@mtcute/tl-runtime";
+import Long from "long";
+import { createAesIgeForMessageOld } from "../utils/crypto/mtproto.js";
+import { EarlyTimer } from "../utils/early-timer.js";
+import { longFromBuffer, randomLong, removeFromLongArray } from "../utils/long-utils.js";
+import { doAuthorization } from "./authorization.js";
+import { MtprotoSession } from "./mtproto-session.js";
+import { PersistentConnection } from "./persistent-connection.js";
+import { TransportError } from "./transports/abstract.js";
+import { MtcuteError, MtTimeoutError, MtArgumentError } from "../types/errors.js";
+const TEMP_AUTH_KEY_EXPIRY = 86400;
+const GET_STATE_INTERVAL = 1500;
+const GZIP_PACKED_ID = 812830625;
+const MSG_CONTAINER_ID = 1945237724;
+const RPC_RESULT_ID = 4082920705;
+const RPC_ERROR_ID = 558156313;
+const INVOKE_AFTER_MSG_ID = 3416209197;
+const INVOKE_AFTER_MSG_SIZE = 12;
+class SessionConnection extends PersistentConnection {
+  _flushTimer = new EarlyTimer();
+  _queuedDestroySession = [];
+  // waitForMessage
+  _pendingWaitForUnencrypted = [];
+  _usePfs;
+  _isPfsBindingPending = false;
+  _isPfsBindingPendingInBackground = false;
+  _pfsUpdateTimeout;
+  _inactivityPendingFlush = false;
+  _readerMap;
+  _writerMap;
+  _crypto;
+  _salts;
+  _session;
+  // todo: we should probably do adaptive ping interval based on rtt like tdlib:
+  // https://github.com/tdlib/td/blob/91aa6c9e4d0774eabf4f8d7f3aa51239032059a6/td/mtproto/SessionConnection.h
+  _pingInterval;
+  // NB: dont forget to update .reset()
+  onDisconnect = new Emitter();
+  onKeyChange = new Emitter();
+  onTmpKeyChange = new Emitter();
+  onFloodDone = new Emitter();
+  onRequestAuth = new Emitter();
+  onAuthBegin = new Emitter();
+  onUpdate = new Emitter();
+  onFutureSalts = new Emitter();
+  _triedReconnectingOn404 = false;
+  constructor(params, log) {
+    super(params, log.create("conn"));
+    this._session = new MtprotoSession(
+      params.crypto,
+      log.create("session"),
+      params.readerMap,
+      params.writerMap,
+      params.salts
+    );
+    this._flushTimer.onTimeout(this._flush.bind(this));
+    this._pingInterval = params.pingInterval;
+    this._readerMap = params.readerMap;
+    this._writerMap = params.writerMap;
+    this._crypto = params.crypto;
+    this._salts = params.salts;
+    this._handleRawMessage = this._handleRawMessage.bind(this);
+    this._usePfs = this.params.usePfs ?? false;
+    this._online = params.platform.isOnline?.() ?? true;
+  }
+  _online;
+  getAuthKey(temp = false) {
+    const key = temp ? this._session._authKeyTemp : this._session._authKey;
+    if (!key.ready) return null;
+    return key.key;
+  }
+  setUsePfs(usePfs) {
+    if (this._usePfs === usePfs) return;
+    this.log.debug("use pfs changed to %s", usePfs);
+    this._usePfs = usePfs;
+    if (!usePfs) {
+      this._isPfsBindingPending = false;
+      this._isPfsBindingPendingInBackground = false;
+      this._session._authKeyTemp.reset();
+      timers.clearTimeout(this._pfsUpdateTimeout);
+    }
+    this._resetSession();
+  }
+  onClosed() {
+    Object.values(this._pendingWaitForUnencrypted).forEach(([prom, timeout]) => {
+      prom.reject(new MtcuteError("Connection closed"));
+      timers.clearTimeout(timeout);
+    });
+    for (const msgId of this._session.pendingMessages.keys()) {
+      const pending = this._session.pendingMessages.get(msgId);
+      if (pending._ === "state") {
+        this._onMessageFailed(msgId, "connection loss", true);
+      }
+    }
+    this.onDisconnect.emit();
+    this.reset();
+  }
+  async destroy() {
+    await super.destroy();
+    this.reset(true);
+  }
+  reset(forever = false) {
+    this._session.initConnectionCalled = false;
+    this._flushTimer.reset();
+    this._salts.isFetching = false;
+    if (forever) {
+      timers.clearTimeout(this._pfsUpdateTimeout);
+      this.onDisconnect.clear();
+      this.onKeyChange.clear();
+      this.onTmpKeyChange.clear();
+      this.onFloodDone.clear();
+      this.onRequestAuth.clear();
+      this.onAuthBegin.clear();
+      this.onUpdate.clear();
+      this.onFutureSalts.clear();
+      this.onWait.clear();
+      this.onUsable.clear();
+      this.onError.clear();
+      this.onError.add((err) => {
+        this.log.warn("caught error after destroying: %s", err);
+      });
+      this._session.reset();
+    }
+  }
+  onConnected() {
+    if (!this._session._authKey.ready) {
+      if (!this.params.isMainConnection) {
+        this.log.info("no auth key, waiting for main connection");
+        return;
+      }
+      this.log.info("no perm auth key, authorizing...");
+      this._authorize();
+      return;
+    }
+    if (this._usePfs && !this._session._authKeyTemp.ready) {
+      this.log.info("no temp auth key but using pfs, authorizing");
+      this._authorizePfs();
+      return;
+    }
+    this.log.info("auth keys are already available");
+    this.onConnectionUsable();
+  }
+  handleError(error) {
+    if (error instanceof TransportError) {
+      if (error.code === 404) {
+        if (this._usePfs) {
+          if (!this._isPfsBindingPending && this._session._authKeyTemp.ready) {
+            this.log.debug("transport error 404, reauthorizing pfs");
+            this._session._authKeyTemp.reset();
+            this._authorizePfs();
+            this._onAllFailed("temp key expired, binding started");
+            return;
+          } else if (this._isPfsBindingPending) {
+            this.log.debug("transport error 404, pfs binding in progress");
+            this._onAllFailed("temp key expired, binding pending");
+            return;
+          }
+        }
+        if (!this._triedReconnectingOn404) {
+          this.log.warn("transport error 404. trying to reconnect");
+          this._triedReconnectingOn404 = true;
+          this._resetSession();
+          return;
+        }
+        this.log.warn("transport error 404, reauthorizing");
+        this._session.resetAuthKey();
+        this._resetSession();
+        this.onKeyChange.emit(null);
+        return;
+      }
+      this.log.error("transport error %d", error.code);
+      this._onAllFailed(`transport error ${error.code}`);
+      if (error.code === 429) {
+        this._session.onTransportFlood(() => this.onFloodDone.emit());
+        return;
+      }
+    }
+    this.onError.emit(error);
+  }
+  onConnectionUsable() {
+    if (this.params.withUpdates) {
+      this.sendRpc({ _: "updates.getState" }).catch((err) => {
+        if (this._destroyed || tl.RpcError.is(err, "AUTH_KEY_UNREGISTERED")) return;
+        this.log.warn("failed to send updates.getState: %e", err);
+      });
+    }
+    this._flushTimer.emitBeforeNext(1e3);
+  }
+  _authorize() {
+    if (this._session.authorizationPending) {
+      this.log.info("_authorize(): authorization already in progress");
+      return;
+    }
+    if (!this.params.isMainConnection) {
+      this.log.debug("_authorize(): non-main connection, requesting...");
+      this.onRequestAuth.emit();
+      return;
+    }
+    this._session.authorizationPending = true;
+    this.onAuthBegin.emit();
+    doAuthorization(this, this._crypto).then(([authKey, serverSalt, timeOffset]) => {
+      this._session._authKey.setup(authKey);
+      this._salts.currentSalt = serverSalt;
+      this._session.updateTimeOffset(timeOffset);
+      this._session.authorizationPending = false;
+      this.onKeyChange.emit(authKey);
+      if (this._usePfs) {
+        return this._authorizePfs();
+      }
+      this.onConnectionUsable();
+    }).catch((err) => {
+      this._session.authorizationPending = false;
+      if (this._destroyed) return;
+      this.log.error("Authorization error: %e", err);
+      this.handleError(err);
+      this.reconnect();
+    });
+  }
+  _authorizePfs(background = false) {
+    if (this._isPfsBindingPending) return;
+    if (this._pfsUpdateTimeout) {
+      timers.clearTimeout(this._pfsUpdateTimeout);
+      this._pfsUpdateTimeout = void 0;
+    }
+    if (this._isPfsBindingPendingInBackground) {
+      this._isPfsBindingPendingInBackground = false;
+      this._isPfsBindingPending = true;
+      return;
+    }
+    if (background) {
+      this._isPfsBindingPendingInBackground = true;
+    } else {
+      this._isPfsBindingPending = true;
+    }
+    doAuthorization(this, this._crypto, TEMP_AUTH_KEY_EXPIRY).then(async ([tempAuthKey, tempServerSalt]) => {
+      if (!this._usePfs) {
+        this.log.info("pfs has been disabled while generating temp key");
+        return;
+      }
+      const tempKey = this._session._authKeyTempSecondary;
+      tempKey.setup(tempAuthKey);
+      const msgId = this._session.getMessageId();
+      this.log.debug(
+        "binding temp_auth_key (%h) to perm_auth_key (%h), msg_id = %l...",
+        tempKey.id,
+        this._session._authKey.id,
+        msgId
+      );
+      const inner = {
+        _: "mt_bind_auth_key_inner",
+        nonce: randomLong(),
+        tempAuthKeyId: longFromBuffer(tempKey.id),
+        permAuthKeyId: longFromBuffer(this._session._authKey.id),
+        tempSessionId: this._session._sessionId,
+        expiresAt: Math.floor(Date.now() / 1e3) + TEMP_AUTH_KEY_EXPIRY
+      };
+      const writer = TlBinaryWriter.alloc(this.params.writerMap, 80);
+      writer.raw(this._crypto.randomBytes(16));
+      writer.long(msgId);
+      writer.int(0);
+      writer.int(40);
+      writer.object(inner);
+      const msgWithoutPadding = writer.result();
+      writer.raw(this._crypto.randomBytes(8));
+      const msgWithPadding = writer.result();
+      const hash = this._crypto.sha1(msgWithoutPadding);
+      const msgKey = hash.subarray(4, 20);
+      const ige = createAesIgeForMessageOld(this._crypto, this._session._authKey.key, msgKey, true);
+      const encryptedData = ige.encrypt(msgWithPadding);
+      const encryptedMessage = u8.concat3(this._session._authKey.id, msgKey, encryptedData);
+      const promise = new Deferred();
+      this._session.pendingMessages.set(msgId, {
+        _: "bind",
+        promise
+      });
+      const request = {
+        _: "auth.bindTempAuthKey",
+        permAuthKeyId: inner.permAuthKeyId,
+        nonce: inner.nonce,
+        expiresAt: inner.expiresAt,
+        encryptedMessage
+      };
+      const reqSize = TlSerializationCounter.countNeededBytes(this._writerMap, request);
+      const reqWriter = TlBinaryWriter.alloc(this._writerMap, reqSize + 16);
+      reqWriter.long(this._registerOutgoingMsgId(msgId));
+      reqWriter.uint(this._session.getSeqNo());
+      reqWriter.uint(reqSize);
+      reqWriter.object(request);
+      const requestEncrypted = tempKey.encryptMessage(
+        reqWriter.result(),
+        tempServerSalt,
+        this._session._sessionId
+      );
+      await this.send(requestEncrypted);
+      const res = await promise.promise;
+      this._session.pendingMessages.delete(msgId);
+      if (!this._usePfs) {
+        this.log.info("pfs has been disabled while binding temp key");
+        return;
+      }
+      if (typeof res === "object") {
+        this.log.error("failed to bind temp key: %s:%s", res.errorCode, res.errorMessage);
+        throw new MtcuteError("Failed to bind temporary key");
+      }
+      this._session._authKeyTempSecondary = this._session._authKeyTemp;
+      this._session._authKeyTemp = tempKey;
+      this._salts.currentSalt = tempServerSalt;
+      this.log.debug("temp key has been bound, exp = %d", inner.expiresAt);
+      this._isPfsBindingPending = false;
+      this._isPfsBindingPendingInBackground = false;
+      this._session.initConnectionCalled = false;
+      this.onTmpKeyChange.emit([tempAuthKey, inner.expiresAt]);
+      this.onConnectionUsable();
+      this._pfsUpdateTimeout = timers.setTimeout(
+        () => {
+          this._pfsUpdateTimeout = void 0;
+          this.log.debug("temp key is expiring soon");
+          this._authorizePfs(true);
+        },
+        (TEMP_AUTH_KEY_EXPIRY - 60) * 1e3
+      );
+    }).catch((err) => {
+      if (this._destroyed) return;
+      this.log.error("PFS Authorization error: %e", err);
+      if (this._isPfsBindingPendingInBackground) {
+        this._isPfsBindingPendingInBackground = false;
+        return this._authorizePfs(true);
+      }
+      this._isPfsBindingPending = false;
+      this.handleError(err);
+      this.reconnect();
+    });
+  }
+  waitForUnencryptedMessage(timeout = 5e3) {
+    if (this._destroyed) {
+      return Promise.reject(new MtcuteError("Connection destroyed"));
+    }
+    const promise = new Deferred();
+    const timeoutId = timers.setTimeout(() => {
+      promise.reject(new MtTimeoutError(timeout));
+      this._pendingWaitForUnencrypted = this._pendingWaitForUnencrypted.filter((it) => it[0] !== promise);
+    }, timeout);
+    this._pendingWaitForUnencrypted.push([promise, timeoutId]);
+    return promise.promise;
+  }
+  onMessage(data) {
+    if (this._pendingWaitForUnencrypted.length) {
+      const int32 = new Int32Array(data.buffer, data.byteOffset, 2);
+      if (int32[0] === 0 && int32[1] === 0) {
+        const [promise, timeout] = this._pendingWaitForUnencrypted.shift();
+        timers.clearTimeout(timeout);
+        promise.resolve(data);
+        return;
+      }
+    }
+    if (!this._session._authKey.ready) {
+      this.log.warn("received message before authorization: %h", data);
+      return;
+    }
+    try {
+      this._session.decryptMessage(data, this._handleRawMessage);
+    } catch (err) {
+      this.log.error("failed to decrypt message: %s\ndata: %h", err, data);
+    }
+  }
+  _handleRawMessage(messageId, seqNo, message) {
+    const objectId = message.uint();
+    if (objectId === GZIP_PACKED_ID) {
+      return this._handleRawMessage(
+        messageId,
+        seqNo,
+        new TlBinaryReader(this._readerMap, this._crypto.gunzip(message.bytes()))
+      );
+    }
+    if (objectId === MSG_CONTAINER_ID) {
+      const count = message.uint();
+      for (let i = 0; i < count; i++) {
+        const msgId = message.long();
+        const seqNo2 = message.uint();
+        const length = message.uint();
+        const obj = message.raw(length);
+        this._handleRawMessage(msgId, seqNo2, new TlBinaryReader(this._readerMap, obj));
+      }
+      return;
+    }
+    if (objectId === RPC_RESULT_ID) {
+      return this._onRpcResult(messageId, message);
+    }
+    this._handleMessage(messageId, message.object(objectId));
+  }
+  _handleMessage(messageId, message_) {
+    if (messageId.isEven()) {
+      this.log.warn("warn: ignoring message with invalid messageId = %s (is even)", messageId);
+      return;
+    }
+    if (this._session.recentIncomingMsgIds.has(messageId)) {
+      this.log.debug("ignoring duplicate message %s", messageId);
+      return;
+    }
+    const message = message_;
+    this.log.debug("received %s (msg_id: %l)", message._, messageId);
+    this._session.recentIncomingMsgIds.add(messageId);
+    switch (message._) {
+      case "mt_msgs_ack":
+      case "mt_http_wait":
+      case "mt_bad_msg_notification":
+      case "mt_bad_server_salt":
+      case "mt_msgs_all_info":
+      case "mt_msgs_state_info":
+      case "mt_msg_detailed_info":
+      case "mt_msg_new_detailed_info":
+        break;
+      default:
+        this._sendAck(messageId);
+    }
+    switch (message._) {
+      case "mt_pong":
+        this._onPong(message);
+        break;
+      case "mt_bad_server_salt":
+        this._onBadServerSalt(message);
+        break;
+      case "mt_bad_msg_notification":
+        this._onBadMsgNotification(messageId, message);
+        break;
+      case "mt_msgs_ack":
+        message.msgIds.forEach((msgId) => this._onMessageAcked(msgId));
+        break;
+      case "mt_new_session_created":
+        this._onNewSessionCreated(message);
+        break;
+      case "mt_msgs_all_info":
+        this._onMessagesInfo(message.msgIds, message.info);
+        break;
+      case "mt_msg_detailed_info":
+        this._onMessageInfo(message.msgId, message.status, message.answerMsgId);
+        break;
+      case "mt_msg_new_detailed_info":
+        this._onMessageInfo(Long.ZERO, 0, message.answerMsgId);
+        break;
+      case "mt_msgs_state_info":
+        this._onMsgsStateInfo(message);
+        break;
+      case "mt_future_salts":
+        this._onFutureSalts(message);
+        break;
+      case "mt_msgs_state_req":
+      case "mt_msg_resend_req":
+        this.log.warn("received %s (msg_id = %l): %j", message._, messageId, message);
+        break;
+      case "mt_destroy_session_ok":
+      case "mt_destroy_session_none":
+        this._onDestroySessionResult(message);
+        break;
+      default:
+        if (tl.isAnyUpdates(message)) {
+          if (this._usable && this.params.inactivityTimeout) {
+            this._rescheduleInactivity();
+          }
+          this.log.verbose("<<< %j", message);
+          if (this.params.disableUpdates) {
+            this.log.warn("received updates, but updates are disabled");
+            break;
+          }
+          this.onUpdate.emit(message);
+          return;
+        }
+        this.log.warn("unknown message received: %j", message);
+    }
+  }
+  _onRpcResult(messageId, message) {
+    if (this._usable && this.params.inactivityTimeout) {
+      this._rescheduleInactivity();
+    }
+    const reqMsgId = message.long();
+    if (reqMsgId.isZero()) {
+      let resultType;
+      try {
+        resultType = message.object()._;
+      } catch {
+        resultType = message.peekUint();
+      }
+      this.log.warn("received rpc_result with %j with req_msg_id = 0", resultType);
+      return;
+    }
+    const msg = this._session.pendingMessages.get(reqMsgId);
+    if (!msg) {
+      let result2;
+      try {
+        result2 = message.object();
+      } catch {
+        result2 = "[failed to parse]";
+      }
+      if (this._session.recentOutgoingMsgIds.has(reqMsgId)) {
+        this.log.debug("received rpc_result again for %l (contains %j)", reqMsgId, result2);
+      } else {
+        this.log.warn("received rpc_result for unknown message %l: %j", reqMsgId, result2);
+      }
+      return;
+    }
+    this._sendAck(messageId);
+    if (msg._ !== "rpc") {
+      if (msg._ === "bind") {
+        this._sendAck(messageId);
+        msg.promise.resolve(message.object());
+        return;
+      }
+      if (msg._ === "cancel") {
+        let result2;
+        try {
+          result2 = message.object();
+        } catch {
+          this.log.debug("failed to parse rpc_result for cancel request %l, ignoring", reqMsgId);
+          return;
+        }
+        this.log.debug("received %s for cancelled request %l: %j", result2._, reqMsgId, result2);
+        this._onMessageAcked(reqMsgId);
+        return;
+      }
+      this.log.error("received rpc_result for %s request %l", msg._, reqMsgId);
+      return;
+    }
+    const rpc = msg.rpc;
+    rpc.resetAbortSignal?.();
+    const resultConstructorId = message.peekUint();
+    let result;
+    const customReader = this._readerMap._results[rpc.method];
+    if (resultConstructorId === RPC_ERROR_ID) {
+      result = message.object();
+    } else if (customReader) {
+      result = customReader(message);
+    } else {
+      const objectId = message.uint();
+      if (objectId === GZIP_PACKED_ID) {
+        const inner = this._crypto.gunzip(message.bytes());
+        result = TlBinaryReader.deserializeObject(this._readerMap, inner);
+      } else {
+        result = message.object(objectId);
+      }
+    }
+    if (rpc.initConn) {
+      this._session.initConnectionCalled = true;
+    }
+    rpc.done = true;
+    this.log.verbose("<<< (%s:%l) %j", rpc.method, reqMsgId, result);
+    if (result._ === "mt_rpc_error") {
+      const res = result;
+      this.log.debug(
+        "received rpc_error [%d:%s] for %l (%s)",
+        res.errorCode,
+        res.errorMessage,
+        reqMsgId,
+        rpc.method
+      );
+      if (rpc.cancelled) return;
+      switch (res.errorMessage) {
+        case "AUTH_KEY_PERM_EMPTY":
+          this._authorizePfs();
+          this._onMessageFailed(reqMsgId, "AUTH_KEY_PERM_EMPTY", true);
+          return;
+        case "CONNECTION_NOT_INITED": {
+          this._session.initConnectionCalled = false;
+          this._onMessageFailed(reqMsgId, res.errorMessage, true);
+          this.sendRpc({ _: "help.getNearestDc" }).then(() => {
+            this.log.debug("additional help.getNearestDc for initConnection ok");
+          }).catch((err) => {
+            this.log.debug("additional help.getNearestDc for initConnection error: %e", err);
+          });
+          return;
+        }
+        case "MSG_WAIT_TIMEOUT":
+        case "MSG_WAIT_FAILED": {
+          if (!rpc.invokeAfter) {
+            this.log.warn("received %s for non-chained request %l", res.errorMessage, reqMsgId);
+            break;
+          }
+          if (this._session.pendingMessages.has(rpc.invokeAfter)) {
+            this.log.debug(
+              "chain %s: waiting for %l before processing %l",
+              rpc.chainId,
+              rpc.invokeAfter,
+              reqMsgId
+            );
+            this._session.getPendingChainedFails(rpc.chainId).insert(rpc);
+          } else {
+            this._session.chains.delete(rpc.chainId);
+            this._onMessageFailed(reqMsgId, "MSG_WAIT_FAILED", true);
+          }
+          return;
+        }
+      }
+      rpc.promise.resolve(res);
+    } else {
+      this.log.debug("received rpc_result (%s) for request %l (%s)", result._, reqMsgId, rpc.method);
+      if (rpc.cancelled) return;
+      rpc.promise.resolve(result);
+    }
+    if (rpc.chainId) {
+      this._processPendingChainedFails(rpc.chainId, reqMsgId);
+    }
+    this._onMessageAcked(reqMsgId);
+    this._session.pendingMessages.delete(reqMsgId);
+  }
+  _processPendingChainedFails(chainId, sinceMsgId) {
+    this._session.removeFromChain(chainId, sinceMsgId);
+    const oldPending = this._session.chainsPendingFails.get(chainId);
+    if (!oldPending?.length) {
+      return;
+    }
+    const idx = oldPending.index({ invokeAfter: sinceMsgId }, true);
+    if (idx === -1) return;
+    const toFail = oldPending.raw.splice(idx);
+    this.log.debug("chain %s: failing %d dependant messages: %L", chainId, toFail.length, toFail);
+    this._session.chains.delete(chainId);
+    for (const rpc of toFail) {
+      this._onMessageFailed(rpc.msgId, "MSG_WAIT_FAILED", true);
+    }
+  }
+  _onMessageAcked(msgId, inContainer = false) {
+    const msg = this._session.pendingMessages.get(msgId);
+    if (!msg) {
+      if (!this._session.recentOutgoingMsgIds.has(msgId)) {
+        this.log.warn("received ack for unknown message %l", msgId);
+      }
+      return;
+    }
+    switch (msg._) {
+      case "container":
+        this.log.debug("received ack for container %l (size = %d)", msgId, msg.msgIds.length);
+        msg.msgIds.forEach((msgId2) => this._onMessageAcked(msgId2, true));
+        this._session.pendingMessages.delete(msgId);
+        break;
+      case "rpc": {
+        const rpc = msg.rpc;
+        this.log.debug("received ack for rpc query %l (%s, acked before = %s)", msgId, rpc.method, rpc.acked);
+        rpc.acked = true;
+        if (!inContainer && rpc.containerId && this._session.pendingMessages.has(rpc.containerId)) {
+          this._onMessageAcked(rpc.containerId);
+        }
+        removeFromLongArray(this._session.queuedStateReq, msgId);
+        removeFromLongArray(this._session.queuedResendReq, msgId);
+        this._session.getStateSchedule.remove(rpc);
+        break;
+      }
+      case "bind":
+      case "cancel":
+        break;
+      default:
+        if (!inContainer) {
+          this.log.warn("received unexpected ack for %s query %l", msg._, msgId);
+        }
+    }
+  }
+  _onAllFailed(reason) {
+    this.log.debug("all messages failed because of %s", reason);
+    for (const msgId of this._session.pendingMessages.keys()) {
+      const info = this._session.pendingMessages.get(msgId);
+      switch (info._) {
+        case "container":
+        case "state":
+        case "resend":
+        case "ping":
+          this.log.debug("forgetting about %s message %l", info._, msgId);
+          this._session.pendingMessages.delete(msgId);
+          break;
+        default:
+          this._onMessageFailed(msgId, reason, true);
+          break;
+      }
+    }
+  }
+  _onMessageFailed(msgId, reason, inContainer = false) {
+    const msgInfo = this._session.pendingMessages.get(msgId);
+    if (!msgInfo) {
+      this.log.debug("unknown message %l failed because of %s", msgId, reason);
+      return;
+    }
+    switch (msgInfo._) {
+      case "container":
+        this.log.debug("container %l (size = %d) failed because of %s", msgId, msgInfo.msgIds.length, reason);
+        msgInfo.msgIds.forEach((msgId2) => this._onMessageFailed(msgId2, reason, true));
+        break;
+      case "ping":
+        this.log.debug("ping (msg_id = %l) failed because of %s", msgId, reason);
+        this._session.resetLastPing(true);
+        break;
+      case "rpc": {
+        const rpc = msgInfo.rpc;
+        this.log.debug("rpc query %l (%s) failed because of %s", msgId, rpc.method, reason);
+        this._session.pendingMessages.delete(msgId);
+        rpc.msgId = void 0;
+        this._enqueueRpc(rpc, true);
+        if (!inContainer && rpc.containerId && this._session.pendingMessages.has(rpc.containerId)) {
+          this._onMessageFailed(rpc.containerId, reason);
+        }
+        removeFromLongArray(this._session.queuedStateReq, msgId);
+        removeFromLongArray(this._session.queuedResendReq, msgId);
+        this._session.getStateSchedule.remove(rpc);
+        break;
+      }
+      case "resend":
+        this.log.debug(
+          "resend request %l (size = %d) failed because of %s",
+          msgId,
+          msgInfo.msgIds.length,
+          reason
+        );
+        this._session.queuedResendReq.splice(0, 0, ...msgInfo.msgIds);
+        this._flushTimer.emitWhenIdle();
+        break;
+      case "state":
+        this.log.debug(
+          "state request %l (size = %d) failed because of %s",
+          msgId,
+          msgInfo.msgIds.length,
+          reason
+        );
+        this._session.queuedStateReq.splice(0, 0, ...msgInfo.msgIds);
+        this._flushTimer.emitWhenIdle();
+        break;
+      case "bind":
+        this.log.debug("temp key binding request %l failed because of %s, retrying", msgId, reason);
+        msgInfo.promise.reject(new Error(reason));
+        break;
+      case "future_salts":
+        this.log.debug("future_salts request %l failed because of %s, will retry", msgId, reason);
+        this._salts.isFetching = false;
+        break;
+    }
+    this._session.pendingMessages.delete(msgId);
+  }
+  _registerOutgoingMsgId(msgId) {
+    this._session.recentOutgoingMsgIds.add(msgId);
+    return msgId;
+  }
+  _onPong({ msgId, pingId }) {
+    const info = this._session.pendingMessages.get(msgId);
+    if (!info) {
+      this.log.warn("received pong to unknown ping (msg_id %l, ping_id %l)", msgId, pingId);
+      return;
+    }
+    if (info._ !== "ping") {
+      this.log.warn("received pong to %s query, not ping (msg_id %l, ping_id %l)", info._, msgId, pingId);
+      return;
+    }
+    if (info.pingId.neq(pingId)) {
+      this.log.warn("received pong to %l, but expected ping_id = %l (got %l)", msgId, info.pingId, pingId);
+    }
+    const rtt = Date.now() - this._session.lastPingTime;
+    this._session.lastPingRtt = rtt;
+    if (info.containerId.neq(msgId)) {
+      this._onMessageAcked(info.containerId);
+    }
+    this.log.debug("received pong: msg_id %l, ping_id %l, rtt = %dms", msgId, pingId, rtt);
+    this._session.resetLastPing();
+  }
+  _onBadServerSalt(msg) {
+    this._salts.currentSalt = msg.newServerSalt;
+    this._onMessageFailed(msg.badMsgId, "bad_server_salt");
+  }
+  _onBadMsgNotification(msgId, msg) {
+    switch (msg.errorCode) {
+      case 16:
+      case 17:
+      case 20: {
+        if (msg.errorCode !== 20) {
+          const serverTime = msgId.high >>> 0;
+          const timeOffset = Math.floor(Date.now() / 1e3) - serverTime;
+          this._session.updateTimeOffset(timeOffset);
+          this.log.debug("server time: %d, corrected offset to %d", serverTime, timeOffset);
+        }
+        this._onMessageFailed(msg.badMsgId, `bad_msg_notification ${msg.errorCode}`);
+        break;
+      }
+      default:
+        this.log.error(
+          "received bad_msg_notification for msg_id = %l, code = %d. session will be reset",
+          msg.badMsgId,
+          msg.errorCode
+        );
+        this._resetSession();
+        break;
+    }
+  }
+  _onNewSessionCreated({ firstMsgId, serverSalt, uniqueId }) {
+    if (uniqueId.eq(this._session.lastSessionCreatedUid)) {
+      this.log.debug("received new_session_created with the same uid = %l, ignoring", uniqueId);
+      return;
+    }
+    if (!this._session.lastSessionCreatedUid.isZero() && !this.params.disableUpdates) {
+      this.onUpdate.emit({ _: "updatesTooLong" });
+    }
+    this._salts.currentSalt = serverSalt;
+    this._triedReconnectingOn404 = false;
+    this.log.debug("received new_session_created, uid = %l, first msg_id = %l", uniqueId, firstMsgId);
+    for (const msgId of this._session.pendingMessages.keys()) {
+      const val = this._session.pendingMessages.get(msgId);
+      if (val._ === "bind") {
+        if (msgId.lt(firstMsgId)) {
+          this._onMessageFailed(msgId, "received in wrong session");
+        }
+        continue;
+      }
+      if (val._ === "container") {
+        if (msgId.lt(firstMsgId)) {
+          this._session.pendingMessages.delete(msgId);
+        }
+        return;
+      }
+      const containerId = val._ === "rpc" ? val.rpc.containerId || msgId : val.containerId;
+      if (containerId.lt(firstMsgId)) {
+        this._onMessageFailed(msgId, "new_session_created", true);
+      }
+    }
+  }
+  _onMessageInfo(msgId, status, answerMsgId) {
+    if (!msgId.isZero()) {
+      const info = this._session.pendingMessages.get(msgId);
+      if (!info) {
+        if (!this._session.recentOutgoingMsgIds.has(msgId)) {
+          this.log.warn("received message info about unknown message %l", msgId);
+        }
+        return;
+      }
+      switch (status & 7) {
+        case 1:
+        case 2:
+        case 3:
+          return this._onMessageFailed(msgId, `message info state ${status}`);
+        case 0:
+          if (!answerMsgId.isZero()) {
+            this.log.warn(
+              "received message info with status = 0: msg_id = %l, status = %d, ans_id = %l",
+              msgId,
+              status,
+              answerMsgId
+            );
+            return this._onMessageFailed(msgId, "message info state = 0, ans_id = 0");
+          }
+        case 4:
+          this._onMessageAcked(msgId);
+          break;
+      }
+    }
+    if (!answerMsgId.isZero() && !this._session.recentIncomingMsgIds.has(answerMsgId)) {
+      this.log.debug("received message info for %l, but answer (%l) was not received yet", msgId, answerMsgId);
+      this._session.queuedResendReq.push(answerMsgId);
+      this._flushTimer.emitWhenIdle();
+      return;
+    }
+    if (answerMsgId.isZero()) {
+      this.log.debug("received message info for %l: message is still pending (status = %d)", msgId, status);
+      return;
+    }
+    this.log.debug("received message info for %l, and answer (%l) was already received", msgId, answerMsgId);
+  }
+  _onMessagesInfo(msgIds, info) {
+    if (msgIds.length !== info.length) {
+      this.log.warn("messages state info was invalid: msg_ids.length !== info.length");
+    }
+    for (let i = 0; i < msgIds.length; i++) {
+      this._onMessageInfo(msgIds[i], info[i], Long.ZERO);
+    }
+  }
+  _onMsgsStateInfo(msg) {
+    const info = this._session.pendingMessages.get(msg.reqMsgId);
+    if (!info) {
+      this.log.warn("received msgs_state_info to unknown request %l", msg.reqMsgId);
+      return;
+    }
+    if (info._ !== "state") {
+      this.log.warn("received msgs_state_info to %s query %l", info._, msg.reqMsgId);
+      return;
+    }
+    this._session.pendingMessages.delete(msg.reqMsgId);
+    this._onMessagesInfo(info.msgIds, msg.info);
+  }
+  _onFutureSalts(msg) {
+    const info = this._session.pendingMessages.get(msg.reqMsgId);
+    if (!info) {
+      this.log.warn("received future_salts to unknown request %l", msg.reqMsgId);
+      return;
+    }
+    if (info._ !== "future_salts") {
+      this.log.warn("received future_salts to %s query %l", info._, msg.reqMsgId);
+      return;
+    }
+    this._session.pendingMessages.delete(msg.reqMsgId);
+    this.log.debug("received future_salts: %d salts", msg.salts.length);
+    this._salts.isFetching = false;
+    this._salts.setFutureSalts(msg.salts.slice());
+    this.onFutureSalts.emit(msg.salts);
+  }
+  _onDestroySessionResult(msg) {
+    const reqMsgId = this._session.destroySessionIdToMsgId.get(msg.sessionId);
+    if (!reqMsgId) {
+      this.log.warn("received %s for unknown session %h", msg._, msg.sessionId);
+      return;
+    }
+    this._session.destroySessionIdToMsgId.delete(msg.sessionId);
+    this._session.pendingMessages.delete(reqMsgId);
+    this.log.debug("received %s for session %h", msg._, msg.sessionId);
+  }
+  _enqueueRpc(rpc, force) {
+    if (this._session.enqueueRpc(rpc, force)) {
+      this._flushTimer.emitWhenIdle();
+    }
+  }
+  _resetSession() {
+    this._queuedDestroySession.push(this._session._sessionId);
+    this._session.resetState(true);
+    this._onAllFailed("session reset");
+    this.reconnect();
+    this._flushTimer.reset();
+  }
+  _sendAck(msgId) {
+    if (this._session.queuedAcks.length === 0) {
+      this._flushTimer.emitBeforeNext(3e4);
+    }
+    this._session.queuedAcks.push(msgId);
+    if (this._session.queuedAcks.length >= 100) {
+      this._flushTimer.emitWhenIdle();
+    }
+  }
+  sendRpc(request, timeout, abortSignal, chainId) {
+    if (this._usable && this.params.inactivityTimeout) {
+      this._rescheduleInactivity();
+    }
+    const method = request._;
+    let obj = request;
+    let initConn = false;
+    if (this.params.disableUpdates) {
+      obj = {
+        _: "invokeWithoutUpdates",
+        query: obj
+      };
+    }
+    if (!this._session.initConnectionCalled) {
+      this.log.debug("wrapping %s with initConnection, layer: %d", method, this.params.layer);
+      obj = {
+        _: "invokeWithLayer",
+        layer: this.params.layer,
+        query: {
+          ...this.params.initConnection,
+          proxy: this._mtproxyInfo,
+          query: obj
+        }
+      };
+      initConn = true;
+    }
+    this.log.verbose(">>> %j", obj);
+    let content = TlBinaryWriter.serializeObject(this._writerMap, obj);
+    if (content.length > 1044404) {
+      throw new MtArgumentError(`Payload is too big (${content.length} > 1044404)`);
+    }
+    let shouldGzip = content.length > 128;
+    if (content.length > 16384) {
+      const middle = ~~((content.length - 1024) / 2);
+      const middlePart = content.subarray(middle, middle + 1024);
+      const gzipped = this._crypto.gzip(middlePart, Math.floor(middlePart.length * 0.9));
+      if (!gzipped) shouldGzip = false;
+    }
+    if (shouldGzip) {
+      const gzipped = this._crypto.gzip(content, Math.floor(content.length * 0.9));
+      if (gzipped) {
+        this.log.debug("gzipped %s (%db -> %db)", method, content.length, gzipped.length);
+        content = gzipped;
+      } else {
+        shouldGzip = false;
+      }
+    }
+    const pending = {
+      method,
+      promise: new Deferred(),
+      data: content,
+      // we will need to know size of gzip_packed overhead in _flush()
+      gzipOverhead: shouldGzip ? 4 + TlSerializationCounter.countBytesOverhead(content.length) : 0,
+      initConn,
+      chainId,
+      // setting them as well so jit can optimize stuff
+      invokeAfter: void 0,
+      sent: void 0,
+      done: void 0,
+      getState: void 0,
+      msgId: void 0,
+      seqNo: void 0,
+      containerId: void 0,
+      acked: void 0,
+      cancelled: void 0,
+      timeout: void 0,
+      resetAbortSignal: void 0
+    };
+    if (abortSignal?.aborted) {
+      pending.promise.reject(abortSignal.reason);
+      return pending.promise.promise;
+    }
+    if (timeout) {
+      pending.timeout = timers.setTimeout(() => this._cancelRpc(pending, true), timeout);
+    }
+    if (abortSignal) {
+      const cancel = () => this._cancelRpc(pending, false, abortSignal);
+      abortSignal.addEventListener("abort", cancel);
+      pending.resetAbortSignal = () => abortSignal.removeEventListener("abort", cancel);
+    }
+    this._enqueueRpc(pending, true);
+    return pending.promise.promise;
+  }
+  notifyNetworkChanged(online) {
+    this._online = online;
+    if (online) {
+      if (this._inactive) return;
+      this.reconnect();
+    } else {
+      this.disconnectManual().catch((err) => {
+        this.log.warn("error while disconnecting: %e", err);
+      });
+    }
+  }
+  _cancelRpc(rpc, onTimeout = false, abortSignal) {
+    if (rpc.done) return;
+    if (rpc.cancelled && !onTimeout) {
+      throw new MtcuteError("RPC was already cancelled");
+    }
+    if (!onTimeout && rpc.timeout) {
+      timers.clearTimeout(rpc.timeout);
+    }
+    rpc.resetAbortSignal?.();
+    if (onTimeout) {
+      rpc.promise.resolve({
+        _: "mt_rpc_error",
+        errorCode: 400,
+        errorMessage: "TIMEOUT"
+      });
+    } else if (abortSignal) {
+      rpc.promise.reject(abortSignal.reason);
+    }
+    rpc.cancelled = true;
+    if (rpc.msgId) {
+      this._session.queuedCancelReq.push(rpc.msgId);
+      this._session.getStateSchedule.remove(rpc);
+      this._flushTimer.emitWhenIdle();
+    } else {
+      this._session.queuedRpc.removeBy((it) => it === rpc);
+    }
+  }
+  _onInactivityTimeout() {
+    let hasPendingRpc = false;
+    for (const it of this._session.pendingMessages.values()) {
+      if (it._ === "rpc") {
+        hasPendingRpc = true;
+        break;
+      }
+    }
+    if (hasPendingRpc) {
+      this.log.debug("waiting for pending rpc queries to finish before closing connection");
+      this._rescheduleInactivity();
+      return;
+    }
+    if (!this._session.hasPendingMessages) {
+      this.log.debug("no pending service messages, closing connection");
+      super._onInactivityTimeout();
+      return;
+    }
+    this._inactivityPendingFlush = true;
+    this._flush();
+  }
+  flushWhenIdle() {
+    this._flushTimer.emitWhenIdle();
+  }
+  _flush() {
+    if (this._disconnectedManually || !this._session._authKey.ready || this._isPfsBindingPending || this._session.current429Timeout) {
+      this.log.debug(
+        "skipping flush, connection is not usable (offline = %b, auth key ready = %b, pfs binding pending = %b, 429 timeout = %b)",
+        this._disconnectedManually,
+        this._session._authKey.ready,
+        this._isPfsBindingPending,
+        this._session.current429Timeout
+      );
+      return;
+    }
+    try {
+      this._doFlush();
+    } catch (e) {
+      this.log.error("flush error: %s", e.stack);
+    }
+    if (this._session.hasPendingMessages) {
+      this._flushTimer.emitWhenIdle();
+    } else {
+      const nextPingTime = this._session.lastPingTime + this._pingInterval;
+      const nextGetScheduleTime = this._session.getStateSchedule.raw[0]?.getState || Infinity;
+      this._flushTimer.emitBefore(Math.min(nextPingTime, nextGetScheduleTime));
+    }
+  }
+  _doFlush() {
+    this.log.debug("flushing send queue. queued rpc: %d", this._session.queuedRpc.length);
+    let packetSize = 0;
+    let messageCount = 0;
+    let containerMessageCount = 0;
+    let containerSize = 0;
+    let ackRequest = null;
+    let ackMsgIds = null;
+    let getFutureSaltsRequest = null;
+    let getFutureSaltsMsgId = null;
+    let pingRequest = null;
+    let pingId = null;
+    let pingMsgId = null;
+    let getStateRequest = null;
+    let getStateMsgId = null;
+    let getStateMsgIds = null;
+    let resendRequest = null;
+    let resendMsgId = null;
+    let resendMsgIds = null;
+    let cancelRpcs = null;
+    let destroySessions = null;
+    let rootMsgId = null;
+    const now = Date.now();
+    if (this._session.queuedAcks.length) {
+      let acks = this._session.queuedAcks;
+      if (acks.length > 8192) {
+        this._session.queuedAcks = acks.slice(8192);
+        acks = acks.slice(0, 8192);
+      } else {
+        this._session.queuedAcks = [];
+      }
+      const obj = {
+        _: "mt_msgs_ack",
+        msgIds: acks
+      };
+      ackMsgIds = obj.msgIds;
+      ackRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+      packetSize += ackRequest.length + 16;
+      messageCount += 1;
+    }
+    if (now - this._session.lastPingTime > this._pingInterval) {
+      if (!this._session.lastPingMsgId.isZero()) {
+        this.log.warn("didn't receive pong for previous ping (msg_id = %l). are we offline?", this._session.lastPingMsgId);
+        this._resetSession();
+        return;
+      }
+      pingId = randomLong();
+      const obj = {
+        _: "mt_ping_delay_disconnect",
+        pingId,
+        // ÷ 1000 * 1.25
+        disconnectDelay: Math.round(this._pingInterval * 125e-5)
+      };
+      this._session.lastPingTime = Date.now();
+      pingRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+      containerSize += pingRequest.length + 16;
+      containerMessageCount += 1;
+    }
+    {
+      if (this._session.queuedStateReq.length) {
+        let ids = this._session.queuedStateReq;
+        if (ids.length > 8192) {
+          this._session.queuedStateReq = ids.slice(8192);
+          ids = ids.slice(0, 8192);
+        } else {
+          this._session.queuedStateReq = [];
+        }
+        getStateMsgIds = ids;
+      }
+      const idx = this._session.getStateSchedule.index({ getState: now }, true);
+      if (idx > 0) {
+        const toGetState = this._session.getStateSchedule.raw.splice(0, idx);
+        if (!getStateMsgIds) getStateMsgIds = [];
+        toGetState.forEach((it) => getStateMsgIds.push(it.msgId));
+      }
+      if (getStateMsgIds) {
+        const obj = {
+          _: "mt_msgs_state_req",
+          msgIds: getStateMsgIds
+        };
+        getStateRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+        packetSize += getStateRequest.length + 16;
+        messageCount += 1;
+      }
+    }
+    if (this._session.queuedResendReq.length) {
+      resendMsgIds = this._session.queuedResendReq;
+      if (resendMsgIds.length > 8192) {
+        this._session.queuedResendReq = resendMsgIds.slice(8192);
+        resendMsgIds = resendMsgIds.slice(0, 8192);
+      } else {
+        this._session.queuedResendReq = [];
+      }
+      const obj = {
+        _: "mt_msg_resend_req",
+        msgIds: resendMsgIds
+      };
+      resendRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+      packetSize += resendRequest.length + 16;
+      messageCount += 1;
+    }
+    if (this._session.queuedCancelReq.length) {
+      containerMessageCount += this._session.queuedCancelReq.length;
+      containerSize += this._session.queuedCancelReq.length * 28;
+      cancelRpcs = this._session.queuedCancelReq;
+      this._session.queuedCancelReq = [];
+    }
+    if (this._queuedDestroySession.length) {
+      containerMessageCount += this._queuedDestroySession.length;
+      containerSize += this._queuedDestroySession.length * 28;
+      destroySessions = this._queuedDestroySession;
+      this._queuedDestroySession = [];
+    }
+    if (this._salts.shouldFetchSalts()) {
+      const obj = {
+        _: "mt_get_future_salts",
+        num: 64
+      };
+      getFutureSaltsRequest = TlBinaryWriter.serializeObject(this._writerMap, obj);
+      containerSize += getFutureSaltsRequest.length + 16;
+      containerMessageCount += 1;
+      this._salts.isFetching = true;
+    }
+    let forceContainer = false;
+    const rpcToSend = [];
+    while (this._session.queuedRpc.length && containerSize < 32768 && containerMessageCount < 1020) {
+      const msg = this._session.queuedRpc.popFront();
+      if (msg.cancelled) continue;
+      rpcToSend.push(msg);
+      containerSize += msg.data.length + 16;
+      if (msg.gzipOverhead) containerSize += msg.gzipOverhead;
+      if (msg.chainId) {
+        containerSize += INVOKE_AFTER_MSG_SIZE;
+      }
+      if (msg.msgId) forceContainer = true;
+      if (msg.method === "upload.getFile") break;
+    }
+    packetSize += containerSize;
+    messageCount += containerMessageCount + rpcToSend.length;
+    if (!messageCount) {
+      this.log.debug("flush did not happen: nothing to flush");
+      return;
+    }
+    const useContainer = forceContainer || messageCount > 1;
+    if (useContainer) packetSize += 24;
+    const writer = TlBinaryWriter.alloc(this._writerMap, packetSize);
+    if (useContainer) {
+      writer.pos += 16;
+      writer.uint(MSG_CONTAINER_ID);
+      writer.uint(messageCount);
+    }
+    const otherPendings = [];
+    if (ackRequest) {
+      this._registerOutgoingMsgId(this._session.writeMessage(writer, ackRequest));
+    }
+    if (pingRequest) {
+      pingMsgId = this._registerOutgoingMsgId(this._session.writeMessage(writer, pingRequest));
+      this._session.lastPingMsgId = pingMsgId;
+      const pingPending = {
+        _: "ping",
+        pingId,
+        containerId: pingMsgId
+      };
+      this._session.pendingMessages.set(pingMsgId, pingPending);
+      otherPendings.push(pingPending);
+    }
+    if (getStateRequest) {
+      getStateMsgId = this._registerOutgoingMsgId(this._session.writeMessage(writer, getStateRequest));
+      const getStatePending = {
+        _: "state",
+        msgIds: getStateMsgIds,
+        containerId: getStateMsgId
+      };
+      this._session.pendingMessages.set(getStateMsgId, getStatePending);
+      otherPendings.push(getStatePending);
+    }
+    if (resendRequest) {
+      resendMsgId = this._registerOutgoingMsgId(this._session.writeMessage(writer, resendRequest));
+      const resendPending = {
+        _: "resend",
+        msgIds: resendMsgIds,
+        containerId: resendMsgId
+      };
+      this._session.pendingMessages.set(resendMsgId, resendPending);
+      otherPendings.push(resendPending);
+    }
+    if (cancelRpcs) {
+      cancelRpcs.forEach((msgId) => {
+        const cancelMsgId = this._registerOutgoingMsgId(
+          this._session.writeMessage(writer, {
+            _: "mt_rpc_drop_answer",
+            reqMsgId: msgId
+          })
+        );
+        const pending = {
+          _: "cancel",
+          msgId,
+          containerId: cancelMsgId
+        };
+        this._session.pendingMessages.set(cancelMsgId, pending);
+        otherPendings.push(pending);
+      });
+    }
+    if (destroySessions) {
+      destroySessions.forEach((sessionId) => {
+        const msgId = this._registerOutgoingMsgId(
+          this._session.writeMessage(writer, {
+            _: "mt_destroy_session",
+            sessionId
+          })
+        );
+        const pending = {
+          _: "destroy_session",
+          sessionId,
+          containerId: msgId
+        };
+        this._session.pendingMessages.set(msgId, pending);
+        this._session.destroySessionIdToMsgId.set(sessionId, msgId);
+        otherPendings.push(pending);
+      });
+    }
+    if (getFutureSaltsRequest) {
+      getFutureSaltsMsgId = this._registerOutgoingMsgId(this._session.writeMessage(writer, getFutureSaltsRequest));
+      const pending = {
+        _: "future_salts",
+        containerId: getFutureSaltsMsgId
+      };
+      this._session.pendingMessages.set(getFutureSaltsMsgId, pending);
+      otherPendings.push(pending);
+    }
+    const getStateTime = now + GET_STATE_INTERVAL;
+    for (let i = 0; i < rpcToSend.length; i++) {
+      const msg = rpcToSend[i];
+      if (!msg.msgId) {
+        const msgId = this._session.getMessageId();
+        const seqNo = this._session.getSeqNo();
+        this.log.debug("%s: msg_id assigned %l, seqno: %d", msg.method, msgId, seqNo);
+        msg.msgId = msgId;
+        msg.seqNo = seqNo;
+        this._session.pendingMessages.set(msgId, {
+          _: "rpc",
+          rpc: msg
+        });
+        if (msg.chainId) {
+          msg.invokeAfter = this._session.addToChain(msg.chainId, msgId);
+          this.log.debug("chain %s: invoke %l after %l", msg.chainId, msg.msgId, msg.invokeAfter);
+        }
+      } else {
+        this.log.debug("%s: msg_id already assigned, reusing %l, seqno: %d", msg.method, msg.msgId, msg.seqNo);
+      }
+      if (msg.getState) {
+        this._session.getStateSchedule.remove(msg);
+      }
+      if (!msg.acked) {
+        msg.getState = getStateTime;
+        this._session.getStateSchedule.insert(msg);
+      }
+      if (rootMsgId === null) rootMsgId = msg.msgId;
+      writer.long(this._registerOutgoingMsgId(msg.msgId));
+      writer.uint(msg.seqNo);
+      const invokeAfterSize = msg.invokeAfter ? INVOKE_AFTER_MSG_SIZE : 0;
+      const writeInvokeAfter = () => {
+        if (!msg.invokeAfter) return;
+        writer.uint(INVOKE_AFTER_MSG_ID);
+        writer.long(msg.invokeAfter);
+      };
+      if (msg.gzipOverhead) {
+        writer.uint(msg.data.length + msg.gzipOverhead + invokeAfterSize);
+        writeInvokeAfter();
+        writer.uint(GZIP_PACKED_ID);
+        writer.bytes(msg.data);
+      } else {
+        writer.uint(msg.data.length + invokeAfterSize);
+        writeInvokeAfter();
+        writer.raw(msg.data);
+      }
+      msg.sent = true;
+    }
+    if (useContainer) {
+      packetSize = writer.pos;
+      const containerId = this._session.getMessageId();
+      const seqNo = this._session.getSeqNo(false);
+      this.log.debug("container: msg_id assigned %l, seqno: %d", containerId, seqNo);
+      writer.pos = 0;
+      rootMsgId = containerId;
+      writer.long(this._registerOutgoingMsgId(containerId));
+      writer.uint(seqNo);
+      writer.uint(packetSize - 16);
+      writer.pos = packetSize;
+      const msgIds = [];
+      for (let i = 0; i < rpcToSend.length; i++) {
+        const msg = rpcToSend[i];
+        msg.containerId = containerId;
+        msgIds.push(msg.msgId);
+      }
+      if (otherPendings.length) {
+        otherPendings.forEach((msg) => {
+          msgIds.push(msg.containerId);
+          msg.containerId = containerId;
+        });
+      }
+      this._session.pendingMessages.set(containerId, {
+        _: "container",
+        msgIds
+      });
+    }
+    const result = writer.result();
+    this.log.debug(
+      "sending %d messages: size = %db, acks = %L, ping = %b (msg_id = %l), state_req = %L (msg_id = %l), resend = %L (msg_id = %l), cancels = %L (msg_id = %l), salts_req = %b (msg_id = %l), rpc = %s, container = %b, root msg_id = %l",
+      messageCount,
+      packetSize,
+      ackMsgIds,
+      pingRequest,
+      pingMsgId,
+      getStateMsgIds,
+      getStateMsgId,
+      resendMsgIds,
+      cancelRpcs,
+      cancelRpcs,
+      resendMsgId,
+      getFutureSaltsRequest,
+      getFutureSaltsMsgId,
+      rpcToSend.map((it) => it.method),
+      useContainer,
+      rootMsgId
+    );
+    const enc = this._session.encryptMessage(result);
+    const promise = this.send(enc).catch((err) => {
+      if (this._destroyed) return;
+      this.log.error("error while sending pending messages (root msg_id = %l): %e", rootMsgId, err);
+      if (ackMsgIds) {
+        this._session.queuedAcks.splice(0, 0, ...ackMsgIds);
+      }
+      if (rootMsgId) {
+        this._onMessageFailed(rootMsgId, "unknown error");
+      }
+    });
+    if (this._inactivityPendingFlush && !this._session.hasPendingMessages) {
+      void promise.then(() => {
+        this.log.debug("pending messages sent, closing connection");
+        this._flushTimer.reset();
+        this._inactivityPendingFlush = false;
+        super._onInactivityTimeout();
+      });
+    }
+  }
+}
+export {
+  SessionConnection
+};