@mtcute/core 0.1.0

package/esm/network/persistent-connection.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { tl } from '@mtcute/tl';
+import { ICryptoProvider, Logger } from '../utils/index.js';
+import { ReconnectionStrategy } from './reconnection.js';
+import { ITelegramTransport, TransportFactory } from './transports/index.js';
+export interface PersistentConnectionParams {
+    crypto: ICryptoProvider;
+    transportFactory: TransportFactory;
+    dc: tl.RawDcOption;
+    testMode: boolean;
+    reconnectionStrategy: ReconnectionStrategy<PersistentConnectionParams>;
+    inactivityTimeout?: number;
+}
+/**
+ * Base class for persistent connections.
+ * Only used for {@link PersistentConnection} and used as a mean of code splitting.
+ * This class doesn't know anything about MTProto, it just manages the transport.
+ */
+export declare abstract class PersistentConnection extends EventEmitter {
+    readonly log: Logger;
+    private _uid;
+    readonly params: PersistentConnectionParams;
+    protected _transport: ITelegramTransport;
+    private _sendOnceConnected;
+    private _lastError;
+    private _consequentFails;
+    private _previousWait;
+    private _reconnectionTimeout;
+    private _inactivityTimeout;
+    private _inactive;
+    _destroyed: boolean;
+    _usable: boolean;
+    protected abstract onConnected(): void;
+    protected abstract onError(err: Error): void;
+    protected abstract onMessage(data: Uint8Array): void;
+    protected constructor(params: PersistentConnectionParams, log: Logger);
+    get isConnected(): boolean;
+    changeTransport(factory: TransportFactory): void;
+    onTransportReady(): void;
+    protected onConnectionUsable(): void;
+    onTransportError(err: Error): void;
+    onTransportClose(): void;
+    connect(): void;
+    reconnect(): void;
+    destroy(): void;
+    protected _rescheduleInactivity(): void;
+    protected _onInactivityTimeout(): void;
+    setInactivityTimeout(timeout?: number): void;
+    send(data: Uint8Array): Promise<void>;
+}

package/esm/network/persistent-connection.js

@@ -0,0 +1,166 @@
+import EventEmitter from 'events';
+import { MtcuteError } from '../types/index.js';
+import { TransportState } from './transports/index.js';
+let nextConnectionUid = 0;
+/**
+ * Base class for persistent connections.
+ * Only used for {@link PersistentConnection} and used as a mean of code splitting.
+ * This class doesn't know anything about MTProto, it just manages the transport.
+ */
+export class PersistentConnection extends EventEmitter {
+    constructor(params, log) {
+        super();
+        this.log = log;
+        this._uid = nextConnectionUid++;
+        this._sendOnceConnected = [];
+        // reconnection
+        this._lastError = null;
+        this._consequentFails = 0;
+        this._previousWait = null;
+        this._reconnectionTimeout = null;
+        // inactivity timeout
+        this._inactivityTimeout = null;
+        this._inactive = true;
+        this._destroyed = false;
+        this._usable = false;
+        this.params = params;
+        this.changeTransport(params.transportFactory);
+        this.log.prefix = `[UID ${this._uid}] `;
+        this._onInactivityTimeout = this._onInactivityTimeout.bind(this);
+    }
+    get isConnected() {
+        return this._transport.state() !== TransportState.Idle;
+    }
+    changeTransport(factory) {
+        if (this._transport) {
+            this._transport.close();
+        }
+        this._transport = factory();
+        this._transport.setup?.(this.params.crypto, this.log);
+        this._transport.on('ready', this.onTransportReady.bind(this));
+        this._transport.on('message', this.onMessage.bind(this));
+        this._transport.on('error', this.onTransportError.bind(this));
+        this._transport.on('close', this.onTransportClose.bind(this));
+    }
+    onTransportReady() {
+        // transport ready does not mean actual mtproto is ready
+        if (this._sendOnceConnected.length) {
+            const sendNext = () => {
+                if (!this._sendOnceConnected.length) {
+                    this.onConnected();
+                    return;
+                }
+                const data = this._sendOnceConnected.shift();
+                this._transport
+                    .send(data)
+                    .then(sendNext)
+                    .catch((err) => {
+                    this.log.error('error sending queued data: %s', err);
+                    this._sendOnceConnected.unshift(data);
+                });
+            };
+            sendNext();
+            return;
+        }
+        this.onConnected();
+    }
+    onConnectionUsable() {
+        const isReconnection = this._consequentFails > 0;
+        // reset reconnection related state
+        this._lastError = null;
+        this._consequentFails = 0;
+        this._previousWait = null;
+        this._usable = true;
+        this.emit('usable', isReconnection);
+        this._rescheduleInactivity();
+    }
+    onTransportError(err) {
+        this._lastError = err;
+        this.onError(err);
+        // transport is expected to emit `close` after `error`
+    }
+    onTransportClose() {
+        // transport closed because of inactivity
+        // obviously we dont want to reconnect then
+        if (this._inactive)
+            return;
+        this._consequentFails += 1;
+        const wait = this.params.reconnectionStrategy(this.params, this._lastError, this._consequentFails, this._previousWait);
+        if (wait === false) {
+            this.destroy();
+            return;
+        }
+        this.emit('wait', wait);
+        this._previousWait = wait;
+        if (this._reconnectionTimeout != null) {
+            clearTimeout(this._reconnectionTimeout);
+        }
+        this._reconnectionTimeout = setTimeout(() => {
+            if (this._destroyed)
+                return;
+            this._reconnectionTimeout = null;
+            this.connect();
+        }, wait);
+    }
+    connect() {
+        if (this.isConnected) {
+            throw new MtcuteError('Connection is already opened!');
+        }
+        if (this._destroyed) {
+            throw new MtcuteError('Connection is already destroyed!');
+        }
+        if (this._reconnectionTimeout != null) {
+            clearTimeout(this._reconnectionTimeout);
+        }
+        this._inactive = false;
+        this._transport.connect(this.params.dc, this.params.testMode);
+    }
+    reconnect() {
+        this._transport.close();
+    }
+    destroy() {
+        if (this._reconnectionTimeout != null) {
+            clearTimeout(this._reconnectionTimeout);
+        }
+        if (this._inactivityTimeout != null) {
+            clearTimeout(this._inactivityTimeout);
+        }
+        this._transport.close();
+        this._transport.removeAllListeners();
+        this._destroyed = true;
+    }
+    _rescheduleInactivity() {
+        if (!this.params.inactivityTimeout)
+            return;
+        if (this._inactivityTimeout)
+            clearTimeout(this._inactivityTimeout);
+        this._inactivityTimeout = setTimeout(this._onInactivityTimeout, this.params.inactivityTimeout);
+    }
+    _onInactivityTimeout() {
+        this.log.info('disconnected because of inactivity for %d', this.params.inactivityTimeout);
+        this._inactive = true;
+        this._inactivityTimeout = null;
+        this._transport.close();
+    }
+    setInactivityTimeout(timeout) {
+        this.params.inactivityTimeout = timeout;
+        if (this._inactivityTimeout) {
+            clearTimeout(this._inactivityTimeout);
+        }
+        if (timeout) {
+            this._rescheduleInactivity();
+        }
+    }
+    async send(data) {
+        if (this._inactive) {
+            this.connect();
+        }
+        if (this._transport.state() === TransportState.Ready) {
+            await this._transport.send(data);
+        }
+        else {
+            this._sendOnceConnected.push(data);
+        }
+    }
+}
+//# sourceMappingURL=persistent-connection.js.map

package/esm/network/persistent-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent-connection.js","sourceRoot":"","sources":["../../../src/network/persistent-connection.ts"],"names":[],"mappings":"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","sourcesContent":["import EventEmitter from 'events'\n\nimport { tl } from '@mtcute/tl'\n\nimport { MtcuteError } from '../types/index.js'\nimport { ICryptoProvider, Logger } from '../utils/index.js'\nimport { ReconnectionStrategy } from './reconnection.js'\nimport { ITelegramTransport, TransportFactory, TransportState } from './transports/index.js'\n\nexport interface PersistentConnectionParams {\n    crypto: ICryptoProvider\n    transportFactory: TransportFactory\n    dc: tl.RawDcOption\n    testMode: boolean\n    reconnectionStrategy: ReconnectionStrategy<PersistentConnectionParams>\n    inactivityTimeout?: number\n}\n\nlet nextConnectionUid = 0\n\n/**\n * Base class for persistent connections.\n * Only used for {@link PersistentConnection} and used as a mean of code splitting.\n * This class doesn't know anything about MTProto, it just manages the transport.\n */\nexport abstract class PersistentConnection extends EventEmitter {\n    private _uid = nextConnectionUid++\n\n    readonly params: PersistentConnectionParams\n    protected _transport!: ITelegramTransport\n\n    private _sendOnceConnected: Uint8Array[] = []\n\n    // reconnection\n    private _lastError: Error | null = null\n    private _consequentFails = 0\n    private _previousWait: number | null = null\n    private _reconnectionTimeout: NodeJS.Timeout | null = null\n\n    // inactivity timeout\n    private _inactivityTimeout: NodeJS.Timeout | null = null\n    private _inactive = true\n\n    _destroyed = false\n    _usable = false\n\n    protected abstract onConnected(): void\n\n    protected abstract onError(err: Error): void\n\n    protected abstract onMessage(data: Uint8Array): void\n\n    protected constructor(\n        params: PersistentConnectionParams,\n        readonly log: Logger,\n    ) {\n        super()\n        this.params = params\n        this.changeTransport(params.transportFactory)\n\n        this.log.prefix = `[UID ${this._uid}] `\n\n        this._onInactivityTimeout = this._onInactivityTimeout.bind(this)\n    }\n\n    get isConnected(): boolean {\n        return this._transport.state() !== TransportState.Idle\n    }\n\n    changeTransport(factory: TransportFactory): void {\n        if (this._transport) {\n            this._transport.close()\n        }\n\n        this._transport = factory()\n        this._transport.setup?.(this.params.crypto, this.log)\n\n        this._transport.on('ready', this.onTransportReady.bind(this))\n        this._transport.on('message', this.onMessage.bind(this))\n        this._transport.on('error', this.onTransportError.bind(this))\n        this._transport.on('close', this.onTransportClose.bind(this))\n    }\n\n    onTransportReady(): void {\n        // transport ready does not mean actual mtproto is ready\n        if (this._sendOnceConnected.length) {\n            const sendNext = () => {\n                if (!this._sendOnceConnected.length) {\n                    this.onConnected()\n\n                    return\n                }\n\n                const data = this._sendOnceConnected.shift()!\n                this._transport\n                    .send(data)\n                    .then(sendNext)\n                    .catch((err) => {\n                        this.log.error('error sending queued data: %s', err)\n                        this._sendOnceConnected.unshift(data)\n                    })\n            }\n\n            sendNext()\n\n            return\n        }\n\n        this.onConnected()\n    }\n\n    protected onConnectionUsable(): void {\n        const isReconnection = this._consequentFails > 0\n\n        // reset reconnection related state\n        this._lastError = null\n        this._consequentFails = 0\n        this._previousWait = null\n        this._usable = true\n        this.emit('usable', isReconnection)\n        this._rescheduleInactivity()\n    }\n\n    onTransportError(err: Error): void {\n        this._lastError = err\n        this.onError(err)\n        // transport is expected to emit `close` after `error`\n    }\n\n    onTransportClose(): void {\n        // transport closed because of inactivity\n        // obviously we dont want to reconnect then\n        if (this._inactive) return\n\n        this._consequentFails += 1\n\n        const wait = this.params.reconnectionStrategy(\n            this.params,\n            this._lastError,\n            this._consequentFails,\n            this._previousWait,\n        )\n\n        if (wait === false) {\n            this.destroy()\n\n            return\n        }\n\n        this.emit('wait', wait)\n\n        this._previousWait = wait\n\n        if (this._reconnectionTimeout != null) {\n            clearTimeout(this._reconnectionTimeout)\n        }\n        this._reconnectionTimeout = setTimeout(() => {\n            if (this._destroyed) return\n            this._reconnectionTimeout = null\n            this.connect()\n        }, wait)\n    }\n\n    connect(): void {\n        if (this.isConnected) {\n            throw new MtcuteError('Connection is already opened!')\n        }\n        if (this._destroyed) {\n            throw new MtcuteError('Connection is already destroyed!')\n        }\n\n        if (this._reconnectionTimeout != null) {\n            clearTimeout(this._reconnectionTimeout)\n        }\n\n        this._inactive = false\n        this._transport.connect(this.params.dc, this.params.testMode)\n    }\n\n    reconnect(): void {\n        this._transport.close()\n    }\n\n    destroy(): void {\n        if (this._reconnectionTimeout != null) {\n            clearTimeout(this._reconnectionTimeout)\n        }\n        if (this._inactivityTimeout != null) {\n            clearTimeout(this._inactivityTimeout)\n        }\n\n        this._transport.close()\n        this._transport.removeAllListeners()\n        this._destroyed = true\n    }\n\n    protected _rescheduleInactivity(): void {\n        if (!this.params.inactivityTimeout) return\n        if (this._inactivityTimeout) clearTimeout(this._inactivityTimeout)\n        this._inactivityTimeout = setTimeout(this._onInactivityTimeout, this.params.inactivityTimeout)\n    }\n\n    protected _onInactivityTimeout(): void {\n        this.log.info('disconnected because of inactivity for %d', this.params.inactivityTimeout)\n        this._inactive = true\n        this._inactivityTimeout = null\n        this._transport.close()\n    }\n\n    setInactivityTimeout(timeout?: number): void {\n        this.params.inactivityTimeout = timeout\n\n        if (this._inactivityTimeout) {\n            clearTimeout(this._inactivityTimeout)\n        }\n\n        if (timeout) {\n            this._rescheduleInactivity()\n        }\n    }\n\n    async send(data: Uint8Array): Promise<void> {\n        if (this._inactive) {\n            this.connect()\n        }\n\n        if (this._transport.state() === TransportState.Ready) {\n            await this._transport.send(data)\n        } else {\n            this._sendOnceConnected.push(data)\n        }\n    }\n}\n"]}

package/esm/network/reconnection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Declares a strategy to handle reconnection.
+ * When a number is returned, that number of MS will be waited before trying to reconnect.
+ * When `false` is returned, connection is not reconnected
+ */
+export type ReconnectionStrategy<T> = (params: T, lastError: Error | null, consequentFails: number, previousWait: number | null) => number | false;
+/**
+ * default reconnection strategy: first - immediate reconnection,
+ * then 1s with linear increase up to 5s (with 1s step)
+ */
+export declare const defaultReconnectionStrategy: ReconnectionStrategy<object>;

package/esm/network/reconnection.js

@@ -0,0 +1,14 @@
+/**
+ * default reconnection strategy: first - immediate reconnection,
+ * then 1s with linear increase up to 5s (with 1s step)
+ */
+export const defaultReconnectionStrategy = (params, lastError, consequentFails, previousWait) => {
+    if (previousWait === null)
+        return 0;
+    if (previousWait === 0)
+        return 1000;
+    if (previousWait >= 5000)
+        return 5000;
+    return Math.min(5000, previousWait + 1000);
+};
+//# sourceMappingURL=reconnection.js.map

package/esm/network/reconnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnection.js","sourceRoot":"","sources":["../../../src/network/reconnection.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAiC,CACrE,MAAM,EACN,SAAS,EACT,eAAe,EACf,YAAY,EACd,EAAE;IACA,IAAI,YAAY,KAAK,IAAI;QAAE,OAAO,CAAC,CAAA;IACnC,IAAI,YAAY,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACnC,IAAI,YAAY,IAAI,IAAI;QAAE,OAAO,IAAI,CAAA;IAErC,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC,CAAA;AAC9C,CAAC,CAAA","sourcesContent":["/**\n * Declares a strategy to handle reconnection.\n * When a number is returned, that number of MS will be waited before trying to reconnect.\n * When `false` is returned, connection is not reconnected\n */\nexport type ReconnectionStrategy<T> = (\n    params: T,\n    lastError: Error | null,\n    consequentFails: number,\n    previousWait: number | null,\n) => number | false\n\n/**\n * default reconnection strategy: first - immediate reconnection,\n * then 1s with linear increase up to 5s (with 1s step)\n */\nexport const defaultReconnectionStrategy: ReconnectionStrategy<object> = (\n    params,\n    lastError,\n    consequentFails,\n    previousWait,\n) => {\n    if (previousWait === null) return 0\n    if (previousWait === 0) return 1000\n    if (previousWait >= 5000) return 5000\n\n    return Math.min(5000, previousWait + 1000)\n}\n"]}

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

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { MtprotoSession } from './mtproto-session.js';
+import { PersistentConnection, PersistentConnectionParams } from './persistent-connection.js';
+export interface SessionConnectionParams extends PersistentConnectionParams {
+    initConnection: tl.RawInitConnectionRequest;
+    inactivityTimeout?: number;
+    niceStacks?: boolean;
+    enableErrorReporting: boolean;
+    layer: number;
+    disableUpdates?: boolean;
+    withUpdates?: boolean;
+    isMainConnection: boolean;
+    isMainDcConnection: boolean;
+    usePfs?: boolean;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+}
+/**
+ * A connection to a single DC.
+ */
+export declare class SessionConnection extends PersistentConnection {
+    readonly _session: MtprotoSession;
+    readonly params: SessionConnectionParams;
+    private _flushTimer;
+    private _queuedDestroySession;
+    private _pendingWaitForUnencrypted;
+    private _usePfs;
+    private _isPfsBindingPending;
+    private _isPfsBindingPendingInBackground;
+    private _pfsUpdateTimeout?;
+    private _inactivityPendingFlush;
+    private _readerMap;
+    private _writerMap;
+    constructor(params: SessionConnectionParams, _session: MtprotoSession);
+    getAuthKey(temp?: boolean): Uint8Array | null;
+    setUsePfs(usePfs: boolean): void;
+    onTransportClose(): void;
+    destroy(): void;
+    reset(forever?: boolean): void;
+    onConnected(): void;
+    protected onError(error: Error): void;
+    protected onConnectionUsable(): void;
+    _authorize(): void;
+    private _authorizePfs;
+    waitForUnencryptedMessage(timeout?: number): Promise<Uint8Array>;
+    protected onMessage(data: Uint8Array): Promise<void>;
+    private _handleRawMessage;
+    private _handleMessage;
+    private _onRpcResult;
+    private _onMessageAcked;
+    private _onAllFailed;
+    private _onMessageFailed;
+    private _registerOutgoingMsgId;
+    private _onPong;
+    private _onBadServerSalt;
+    private _onBadMsgNotification;
+    private _onNewSessionCreated;
+    private _onMessageInfo;
+    private _onMessagesInfo;
+    private _onMsgsStateInfo;
+    private _onDestroySessionResult;
+    private _enqueueRpc;
+    _resetSession(): void;
+    private _sendAck;
+    sendRpc<T extends tl.RpcMethod>(request: T, stack?: string, timeout?: number, abortSignal?: AbortSignal): Promise<tl.RpcCallReturn[T['_']]>;
+    private _cancelRpc;
+    protected _onInactivityTimeout(): void;
+    flushWhenIdle(): void;
+    private _flush;
+    private _doFlush;
+}