@mtcute/core 0.18.0-rc.5 → 0.19.0

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/mtproxy/_fake-tls.d.cts

@@ -0,0 +1,22 @@
+import { ICryptoProvider } from '../../utils/crypto/abstract.js';
+import { Logger } from '../../utils/logger.js';
+import { IPacketCodec } from '../transports/index.js';
+import { Bytes, ISyncWritable } from '@fuman/io';
+export declare function generateFakeTlsHeader(domain: Uint8Array, secret: Uint8Array, crypto: ICryptoProvider): Promise<Uint8Array>;
+/**
+ * Fake TLS packet codec, used for some MTProxies.
+ *
+ * Must only be used inside {@link MtProxyTcpTransport}
+ * @internal
+ */
+export declare class FakeTlsPacketCodec implements IPacketCodec {
+    readonly _inner: IPacketCodec;
+    constructor(_inner: IPacketCodec);
+    private _isFirstTls;
+    setup?(crypto: ICryptoProvider, log: Logger): void;
+    private _tag;
+    tag(): Promise<Uint8Array>;
+    encode(packet: Uint8Array, into: ISyncWritable): Promise<void>;
+    decode(reader: Bytes, eof: boolean): Promise<Uint8Array | null>;
+    reset(): void;
+}

package/network/mtproxy/index.d.cts

@@ -0,0 +1,42 @@
+import { ITcpConnection, TcpEndpoint } from '@fuman/net';
+import { tl } from '@mtcute/tl';
+import { BasicDcOption, ICryptoProvider, Logger } from '../../utils/index.js';
+import { IPacketCodec, ITelegramConnection, TelegramTransport } from '../transports/index.js';
+/**
+ * MTProto proxy settings
+ */
+export interface MtProxySettings {
+    /**
+     * Host or IP of the proxy (e.g. `proxy.example.com`, `1.2.3.4`)
+     */
+    host: string;
+    /**
+     * Port of the proxy (e.g. `8888`)
+     */
+    port: number;
+    /**
+     * Secret of the proxy, optionally encoded either as hex or base64
+     */
+    secret: string | Uint8Array;
+}
+/**
+ * Base for a TCP transport that connects via an MTProxy
+ */
+export declare abstract class BaseMtProxyTransport implements TelegramTransport {
+    abstract _connectTcp(endpoint: TcpEndpoint): Promise<ITcpConnection>;
+    readonly _proxy: MtProxySettings;
+    private _rawSecret;
+    private _randomPadding;
+    private _fakeTlsDomain;
+    private _crypto;
+    private _log;
+    setup(crypto: ICryptoProvider, log: Logger): void;
+    /**
+     * @param proxy  Information about the proxy
+     */
+    constructor(proxy: MtProxySettings);
+    getMtproxyInfo(): tl.RawInputClientProxy;
+    packetCodec(dc: BasicDcOption): IPacketCodec;
+    connect(): Promise<ITelegramConnection>;
+    private _handleConnectFakeTls;
+}

package/network/multi-session-connection.cjs

@@ -6,7 +6,6 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const utils = require("@fuman/utils");
-const mtprotoSession = require("./mtproto-session.cjs");
 const sessionConnection = require("./session-connection.cjs");
 class MultiSessionConnection {
   constructor(params, _count, log, logPrefix = "") {
@@ -15,11 +14,9 @@ class MultiSessionConnection {
     this._log = log.create("multi");
     if (logPrefix) this._log.prefix = `[${logPrefix}] `;
     this._enforcePfs = _count > 1 && params.isMainConnection;
-    this._sessions = [];
     this._updateConnections();
   }
   _log;
-  _sessions;
   _enforcePfs = false;
   // NB: dont forget to update .reset()
   onRequestKeys = new utils.Emitter();
@@ -37,31 +34,10 @@ class MultiSessionConnection {
     this._count = count;
     this._updateConnections(connect);
   }
-  _updateSessions() {
-    this._log.debug("updating sessions count: %d -> %d", this._sessions.length, this._count);
-    if (this._sessions.length === this._count) return;
-    if (this._sessions.length > this._count) {
-      for (let i = this._sessions.length - 1; i >= this._count; i--) {
-        this._sessions[i].reset();
-      }
-      this._sessions.splice(this._count);
-      return;
-    }
-    while (this._sessions.length < this._count) {
-      const idx = this._sessions.length;
-      const session = new mtprotoSession.MtprotoSession(
-        this.params.crypto,
-        this._log.create("session"),
-        this.params.readerMap,
-        this.params.writerMap,
-        this.params.salts
-      );
-      if (idx !== 0) session._authKey = this._sessions[0]._authKey;
-      this._sessions.push(session);
-    }
+  getCount() {
+    return this._count;
   }
   _updateConnections(connect = false) {
-    this._updateSessions();
     if (this._connections.length === this._count) return;
     this._log.debug("updating connections count: %d -> %d", this._connections.length, this._count);
     const newEnforcePfs = this._count > 1 && this.params.isMainConnection;
@@ -92,7 +68,6 @@ class MultiSessionConnection {
       });
     }
     for (let i = this._connections.length; i < this._count; i++) {
-      const session = this._sessions[i];
       const conn = new sessionConnection.SessionConnection(
         {
           ...this.params,
@@ -100,7 +75,7 @@ class MultiSessionConnection {
           isMainConnection: this.params.isMainConnection && i === 0,
           withUpdates: this.params.isMainConnection && this.params.isMainDcConnection && !this.params.disableUpdates
         },
-        session
+        this._log
       );
       if (this.params.isMainConnection && this.params.isMainDcConnection) {
         conn.onUpdate.add((update) => this.onUpdate.emit(update));
@@ -133,13 +108,13 @@ class MultiSessionConnection {
         this._connections.forEach((it) => it.flushWhenIdle());
       });
       this._connections.push(conn);
+      if (this._authKey !== null) conn._session._authKey.setup(this._authKey);
       if (connect && !enforcePfsChanged) conn.connect();
     }
   }
   _destroyed = false;
   async destroy() {
     await Promise.all(this._connections.map((conn) => conn.destroy()));
-    this._sessions.forEach((sess) => sess.reset());
     this.onRequestKeys.clear();
     this.onError.clear();
     this.onUpdate.clear();
@@ -175,14 +150,19 @@ class MultiSessionConnection {
     if (this._connections[0].isConnected) return;
     this.connect();
   }
-  setAuthKey(authKey, temp = false, idx = 0) {
-    const session = this._sessions[idx];
-    const key = temp ? session._authKeyTemp : session._authKey;
-    key.setup(authKey);
+  _authKey = null;
+  setAuthKey(authKey) {
+    this._authKey = authKey;
+    for (const conn of this._connections) {
+      conn._session._authKey.setup(authKey);
+    }
+  }
+  setTempAuthKey(authKey, idx) {
+    this._connections[idx]?._session._authKeyTemp.setup(authKey);
   }
   resetAuthKeys() {
-    for (const session of this._sessions) {
-      session.reset(true);
+    for (const conn of this._connections) {
+      conn._session.reset(true);
     }
     this.notifyKeyChange();
   }
@@ -194,14 +174,16 @@ class MultiSessionConnection {
     }
   }
   notifyKeyChange() {
-    const session = this._sessions[0];
-    if (this.params.usePfs && !session._authKeyTemp.ready) {
-      this._log.debug("temp auth key needed but not ready, ignoring key change");
-      return;
-    }
-    if (this._sessions[0].queuedRpc.length) {
-      this._log.debug("notifying key change on the connection due to queued rpc");
-      this._connections.forEach((conn) => conn.onConnected());
+    for (const conn of this._connections) {
+      const session = conn._session;
+      if (this.params.usePfs && !session._authKeyTemp.ready) {
+        this._log.debug("temp auth key needed but not ready, ignoring key change");
+        continue;
+      }
+      if (session.queuedRpc.length) {
+        this._log.debug("notifying key change on the connection due to queued rpc");
+        this._connections.forEach((conn2) => conn2.onConnected());
+      }
     }
   }
   notifyNetworkChanged(connected) {

package/network/multi-session-connection.d.cts

@@ -0,0 +1,43 @@
+import { mtp, tl } from '@mtcute/tl';
+import { Logger } from '../utils/index.js';
+import { SessionConnectionParams, SessionConnection } from './session-connection.js';
+import { TelegramTransport } from './transports/index.js';
+import { Deferred, Emitter } from '@fuman/utils';
+export declare class MultiSessionConnection {
+    readonly params: SessionConnectionParams;
+    private _count;
+    private _log;
+    private _enforcePfs;
+    readonly onRequestKeys: Emitter<Deferred<void>>;
+    readonly onError: Emitter<Error>;
+    readonly onUpdate: Emitter<tl.TypeUpdates>;
+    readonly onKeyChange: Emitter<[number, Uint8Array | null]>;
+    readonly onTmpKeyChange: Emitter<[number, Uint8Array | null, number]>;
+    readonly onFutureSalts: Emitter<mtp.RawMt_future_salt[]>;
+    readonly onAuthBegin: Emitter<number>;
+    readonly onUsable: Emitter<number>;
+    readonly onWait: Emitter<number>;
+    readonly onRequestAuth: Emitter<number>;
+    constructor(params: SessionConnectionParams, _count: number, log: Logger, logPrefix?: string);
+    readonly _connections: SessionConnection[];
+    setCount(count: number, connect?: boolean): void;
+    getCount(): number;
+    private _updateConnections;
+    _destroyed: boolean;
+    destroy(): Promise<void>;
+    private _nextConnection;
+    sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    connect(): void;
+    ensureConnected(): void;
+    private _authKey;
+    setAuthKey(authKey: Uint8Array | null): void;
+    setTempAuthKey(authKey: Uint8Array | null, idx: number): void;
+    resetAuthKeys(): void;
+    setInactivityTimeout(timeout?: number): void;
+    notifyKeyChange(): void;
+    notifyNetworkChanged(connected: boolean): void;
+    requestAuth(): void;
+    resetSessions(): void;
+    changeTransport(factory: TelegramTransport): Promise<void>;
+    getPoolSize(): number;
+}

package/network/multi-session-connection.d.ts

@@ -3,12 +3,10 @@ import { Logger } from '../utils/index.js';
 import { SessionConnectionParams, SessionConnection } from './session-connection.js';
 import { TelegramTransport } from './transports/index.js';
 import { Deferred, Emitter } from '@fuman/utils';
-import { MtprotoSession } from './mtproto-session.js';
 export declare class MultiSessionConnection {
     readonly params: SessionConnectionParams;
     private _count;
     private _log;
-    readonly _sessions: MtprotoSession[];
     private _enforcePfs;
     readonly onRequestKeys: Emitter<Deferred<void>>;
     readonly onError: Emitter<Error>;
@@ -21,9 +19,9 @@ export declare class MultiSessionConnection {
     readonly onWait: Emitter<number>;
     readonly onRequestAuth: Emitter<number>;
     constructor(params: SessionConnectionParams, _count: number, log: Logger, logPrefix?: string);
-    protected _connections: SessionConnection[];
+    readonly _connections: SessionConnection[];
     setCount(count: number, connect?: boolean): void;
-    private _updateSessions;
+    getCount(): number;
     private _updateConnections;
     _destroyed: boolean;
     destroy(): Promise<void>;
@@ -31,7 +29,9 @@ export declare class MultiSessionConnection {
     sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
     connect(): void;
     ensureConnected(): void;
-    setAuthKey(authKey: Uint8Array | null, temp?: boolean, idx?: number): void;
+    private _authKey;
+    setAuthKey(authKey: Uint8Array | null): void;
+    setTempAuthKey(authKey: Uint8Array | null, idx: number): void;
     resetAuthKeys(): void;
     setInactivityTimeout(timeout?: number): void;
     notifyKeyChange(): void;

package/network/multi-session-connection.js

@@ -1,5 +1,4 @@
 import { Emitter, Deferred, unknownToError } from "@fuman/utils";
-import { MtprotoSession } from "./mtproto-session.js";
 import { SessionConnection } from "./session-connection.js";
 class MultiSessionConnection {
   constructor(params, _count, log, logPrefix = "") {
@@ -8,11 +7,9 @@ class MultiSessionConnection {
     this._log = log.create("multi");
     if (logPrefix) this._log.prefix = `[${logPrefix}] `;
     this._enforcePfs = _count > 1 && params.isMainConnection;
-    this._sessions = [];
     this._updateConnections();
   }
   _log;
-  _sessions;
   _enforcePfs = false;
   // NB: dont forget to update .reset()
   onRequestKeys = new Emitter();
@@ -30,31 +27,10 @@ class MultiSessionConnection {
     this._count = count;
     this._updateConnections(connect);
   }
-  _updateSessions() {
-    this._log.debug("updating sessions count: %d -> %d", this._sessions.length, this._count);
-    if (this._sessions.length === this._count) return;
-    if (this._sessions.length > this._count) {
-      for (let i = this._sessions.length - 1; i >= this._count; i--) {
-        this._sessions[i].reset();
-      }
-      this._sessions.splice(this._count);
-      return;
-    }
-    while (this._sessions.length < this._count) {
-      const idx = this._sessions.length;
-      const session = new MtprotoSession(
-        this.params.crypto,
-        this._log.create("session"),
-        this.params.readerMap,
-        this.params.writerMap,
-        this.params.salts
-      );
-      if (idx !== 0) session._authKey = this._sessions[0]._authKey;
-      this._sessions.push(session);
-    }
+  getCount() {
+    return this._count;
   }
   _updateConnections(connect = false) {
-    this._updateSessions();
     if (this._connections.length === this._count) return;
     this._log.debug("updating connections count: %d -> %d", this._connections.length, this._count);
     const newEnforcePfs = this._count > 1 && this.params.isMainConnection;
@@ -85,7 +61,6 @@ class MultiSessionConnection {
       });
     }
     for (let i = this._connections.length; i < this._count; i++) {
-      const session = this._sessions[i];
       const conn = new SessionConnection(
         {
           ...this.params,
@@ -93,7 +68,7 @@ class MultiSessionConnection {
           isMainConnection: this.params.isMainConnection && i === 0,
           withUpdates: this.params.isMainConnection && this.params.isMainDcConnection && !this.params.disableUpdates
         },
-        session
+        this._log
       );
       if (this.params.isMainConnection && this.params.isMainDcConnection) {
         conn.onUpdate.add((update) => this.onUpdate.emit(update));
@@ -126,13 +101,13 @@ class MultiSessionConnection {
         this._connections.forEach((it) => it.flushWhenIdle());
       });
       this._connections.push(conn);
+      if (this._authKey !== null) conn._session._authKey.setup(this._authKey);
       if (connect && !enforcePfsChanged) conn.connect();
     }
   }
   _destroyed = false;
   async destroy() {
     await Promise.all(this._connections.map((conn) => conn.destroy()));
-    this._sessions.forEach((sess) => sess.reset());
     this.onRequestKeys.clear();
     this.onError.clear();
     this.onUpdate.clear();
@@ -168,14 +143,19 @@ class MultiSessionConnection {
     if (this._connections[0].isConnected) return;
     this.connect();
   }
-  setAuthKey(authKey, temp = false, idx = 0) {
-    const session = this._sessions[idx];
-    const key = temp ? session._authKeyTemp : session._authKey;
-    key.setup(authKey);
+  _authKey = null;
+  setAuthKey(authKey) {
+    this._authKey = authKey;
+    for (const conn of this._connections) {
+      conn._session._authKey.setup(authKey);
+    }
+  }
+  setTempAuthKey(authKey, idx) {
+    this._connections[idx]?._session._authKeyTemp.setup(authKey);
   }
   resetAuthKeys() {
-    for (const session of this._sessions) {
-      session.reset(true);
+    for (const conn of this._connections) {
+      conn._session.reset(true);
     }
     this.notifyKeyChange();
   }
@@ -187,14 +167,16 @@ class MultiSessionConnection {
     }
   }
   notifyKeyChange() {
-    const session = this._sessions[0];
-    if (this.params.usePfs && !session._authKeyTemp.ready) {
-      this._log.debug("temp auth key needed but not ready, ignoring key change");
-      return;
-    }
-    if (this._sessions[0].queuedRpc.length) {
-      this._log.debug("notifying key change on the connection due to queued rpc");
-      this._connections.forEach((conn) => conn.onConnected());
+    for (const conn of this._connections) {
+      const session = conn._session;
+      if (this.params.usePfs && !session._authKeyTemp.ready) {
+        this._log.debug("temp auth key needed but not ready, ignoring key change");
+        continue;
+      }
+      if (session.queuedRpc.length) {
+        this._log.debug("notifying key change on the connection due to queued rpc");
+        this._connections.forEach((conn2) => conn2.onConnected());
+      }
     }
   }
   notifyNetworkChanged(connected) {

package/network/network-manager.cjs

@@ -107,11 +107,11 @@ class DcConnectionManager {
   _setupMulti(kind) {
     const connection = this[kind];
     connection.onKeyChange.add(([idx, key]) => {
-      if (kind !== "main") {
+      if (kind !== "main" && key !== null) {
         this.manager._log.warn("got key-change from non-main connection, ignoring");
         return;
       }
-      this.manager._log.debug("key change for dc %d from connection %d", this.dcId, idx);
+      this.manager._log.debug("key change (empty=%b) for dc %d from connection %d", key === null, this.dcId, idx);
       this.upload.setAuthKey(key);
       this.download.setAuthKey(key);
       this.downloadSmall.setAuthKey(key);
@@ -126,18 +126,10 @@ class DcConnectionManager {
     });
     connection.onTmpKeyChange.add(([idx, key, expires]) => {
       if (kind !== "main") {
-        this.manager._log.warn("got tmp-key-change from non-main connection, ignoring");
         return;
       }
       this.manager._log.debug("temp key change for dc %d from connection %d", this.dcId, idx);
-      this.upload.setAuthKey(key, true);
-      this.download.setAuthKey(key, true);
-      this.downloadSmall.setAuthKey(key, true);
-      Promise.resolve(this.manager._storage.provider.authKeys.setTemp(this.dcId, idx, key, expires * 1e3)).then(() => {
-        this.upload.notifyKeyChange();
-        this.download.notifyKeyChange();
-        this.downloadSmall.notifyKeyChange();
-      }).catch((e) => {
+      Promise.resolve(this.manager._storage.provider.authKeys.setTemp(this.dcId, idx, key, expires * 1e3)).catch((e) => {
         this.manager._log.warn("failed to save temp auth key %d for dc %d: %e", idx, this.dcId, e);
         this.manager.params.emitError(e);
       });
@@ -199,14 +191,9 @@ class DcConnectionManager {
     if (this.manager.params.usePfs || forcePfs) {
       const now = Date.now();
       await Promise.all(
-        this.main._sessions.map(async (_, i) => {
+        Array.from({ length: this.main.getCount() }, async (_, i) => {
           const temp = await this.manager._storage.provider.authKeys.getTemp(this.dcId, i, now);
-          this.main.setAuthKey(temp, true, i);
-          if (i === 0) {
-            this.upload.setAuthKey(temp, true);
-            this.download.setAuthKey(temp, true);
-            this.downloadSmall.setAuthKey(temp, true);
-          }
+          this.main.setTempAuthKey(temp, i);
         })
       );
     }
@@ -233,7 +220,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.17.1",
+      appVersion: "0.19.0",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -551,7 +538,7 @@ class NetworkManager {
     this._resetOnNetworkChange?.();
   }
   getMtprotoMessageId() {
-    return this._primaryDc.main._sessions[0].getMessageId();
+    return this._primaryDc.main._connections[0]._session.getMessageId();
   }
   async recreateDc(dcId) {
     this._log.debug("recreating dc %d", dcId);