@mtcute/core 0.1.0

package/cjs/storage/abstract.d.ts

@@ -0,0 +1,174 @@
+import { tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { BasicPeerType, MaybeAsync } from '../types/index.js';
+import { Logger } from '../utils/index.js';
+export declare namespace ITelegramStorage {
+    /** Information about a cached peer */
+    interface PeerInfo {
+        /** Peer marked ID */
+        id: number;
+        /** Peer access hash */
+        accessHash: tl.Long;
+        /** Peer type */
+        type: BasicPeerType;
+        /** Peer username, if any */
+        username?: string;
+        /** Peer phone number, if available */
+        phone?: string;
+        /** Full TL object with the cached entity */
+        full: tl.TypeUser | tl.TypeChat;
+    }
+    /** Information about currently logged in user */
+    interface SelfInfo {
+        /** Whether this is a bot */
+        isBot: boolean;
+        /** Current user's ID */
+        userId: number;
+    }
+    /** Information about preferred DC-s for the user */
+    interface DcOptions {
+        /** Main DC */
+        main: tl.RawDcOption;
+        /** Media DC. Can be the same as main */
+        media: tl.RawDcOption;
+    }
+}
+/**
+ * Abstract interface for persistent storage.
+ *
+ * In some cases you may want to extend existing MemorySession
+ * and override save()/load()/destroy() methods, but you are also free
+ * to implement your own session (be sure to refer to MemorySession
+ * source code to avoid shooting your leg though)
+ *
+ * Note that even though set methods *can* be async, you should only
+ * write updates to the disk when `save()` is called.
+ */
+export interface ITelegramStorage {
+    /**
+     * This method is called before any other.
+     * For storages that use logging, logger instance.
+     * For storages that use binary storage, binary maps
+     */
+    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void;
+    /**
+     * Load session from some external storage.
+     * Should be used either to load session content from file/network/etc
+     * to memory, or to open required connections to fetch session content later
+     */
+    load?(): MaybeAsync<void>;
+    /**
+     * Save session to some external storage.
+     * Should be used to commit pending changes in the session.
+     * For example, saving session content to file/network/etc,
+     * or committing a database transaction
+     */
+    save?(): MaybeAsync<void>;
+    /**
+     * Cleanup session and release all used resources.
+     */
+    destroy?(): MaybeAsync<void>;
+    /**
+     * Reset session to its default state
+     */
+    reset(): void;
+    /**
+     * Set default datacenter to use with this session.
+     */
+    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>;
+    /**
+     * Get default datacenter for this session
+     * (by default should return null)
+     */
+    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>;
+    /**
+     * Get auth_key for a given DC
+     * (returning null will start authorization)
+     * For temp keys: should also return null if the key has expired
+     *
+     * @param dcId DC ID
+     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)
+     */
+    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>;
+    /**
+     * Set auth_key for a given DC
+     */
+    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>;
+    /**
+     * Set temp_auth_key for a given DC
+     * expiresAt is unix time in ms
+     */
+    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>;
+    /**
+     * Remove all saved auth keys (both temp and perm)
+     * for the given DC. Used when perm_key becomes invalid,
+     * meaning all temp_keys also become invalid
+     */
+    dropAuthKeysFor(dcId: number): MaybeAsync<void>;
+    /**
+     * Get information about currently logged in user (if available)
+     */
+    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>;
+    /**
+     * Save information about currently logged in user
+     */
+    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>;
+    /**
+     * Update local database of input peers from the peer info list
+     */
+    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>;
+    /**
+     * Find a peer in local database by its marked ID
+     */
+    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>;
+    /**
+     * Find a peer in local database by its username
+     */
+    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>;
+    /**
+     * Find a peer in local database by its phone number
+     */
+    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>;
+    /**
+     * Get updates state (if available), represented as a tuple
+     * containing: `pts, qts, date, seq`
+     */
+    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>;
+    /**
+     * Set common `pts` value
+     */
+    setUpdatesPts(val: number): MaybeAsync<void>;
+    /**
+     * Set common `qts` value
+     */
+    setUpdatesQts(val: number): MaybeAsync<void>;
+    /**
+     * Set updates `date` value
+     */
+    setUpdatesDate(val: number): MaybeAsync<void>;
+    /**
+     * Set updates `seq` value
+     */
+    setUpdatesSeq(val: number): MaybeAsync<void>;
+    /**
+     * Get channel `pts` value
+     */
+    getChannelPts(entityId: number): MaybeAsync<number | null>;
+    /**
+     * Set channels `pts` values in batch.
+     * Storage is supposed to replace stored channel `pts` values
+     * with given in the object (key is unmarked peer id, value is the `pts`)
+     */
+    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>;
+    /**
+     * Get cached peer information by their marked ID.
+     * Return `null` if caching is not supported, or the entity
+     * is not cached (yet).
+     *
+     * This is primarily used when a `min` entity is encountered
+     * in an update, or when a *short* update is encountered.
+     * Returning `null` will require re-fetching that
+     * update with the peers added, which might not be very efficient.
+     */
+    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>;
+}

package/cjs/storage/abstract.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=abstract.js.map

package/cjs/storage/abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../src/storage/abstract.ts"],"names":[],"mappings":"","sourcesContent":["import { tl } from '@mtcute/tl'\nimport { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'\n\nimport { BasicPeerType, MaybeAsync } from '../types/index.js'\nimport { Logger } from '../utils/index.js'\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace ITelegramStorage {\n    /** Information about a cached peer */\n    export interface PeerInfo {\n        /** Peer marked ID */\n        id: number\n        /** Peer access hash */\n        accessHash: tl.Long\n        /** Peer type */\n        type: BasicPeerType\n        /** Peer username, if any */\n        username?: string\n        /** Peer phone number, if available */\n        phone?: string\n\n        /** Full TL object with the cached entity */\n        full: tl.TypeUser | tl.TypeChat\n    }\n\n    /** Information about currently logged in user */\n    export interface SelfInfo {\n        /** Whether this is a bot */\n        isBot: boolean\n        /** Current user's ID */\n        userId: number\n    }\n\n    /** Information about preferred DC-s for the user */\n    export interface DcOptions {\n        /** Main DC */\n        main: tl.RawDcOption\n        /** Media DC. Can be the same as main */\n        media: tl.RawDcOption\n    }\n}\n\n/**\n * Abstract interface for persistent storage.\n *\n * In some cases you may want to extend existing MemorySession\n * and override save()/load()/destroy() methods, but you are also free\n * to implement your own session (be sure to refer to MemorySession\n * source code to avoid shooting your leg though)\n *\n * Note that even though set methods *can* be async, you should only\n * write updates to the disk when `save()` is called.\n */\nexport interface ITelegramStorage {\n    /**\n     * This method is called before any other.\n     * For storages that use logging, logger instance.\n     * For storages that use binary storage, binary maps\n     */\n    setup?(log: Logger, readerMap: TlReaderMap, writerMap: TlWriterMap): void\n\n    /**\n     * Load session from some external storage.\n     * Should be used either to load session content from file/network/etc\n     * to memory, or to open required connections to fetch session content later\n     */\n    load?(): MaybeAsync<void>\n    /**\n     * Save session to some external storage.\n     * Should be used to commit pending changes in the session.\n     * For example, saving session content to file/network/etc,\n     * or committing a database transaction\n     */\n    save?(): MaybeAsync<void>\n    /**\n     * Cleanup session and release all used resources.\n     */\n    destroy?(): MaybeAsync<void>\n\n    /**\n     * Reset session to its default state\n     */\n    reset(): void\n\n    /**\n     * Set default datacenter to use with this session.\n     */\n    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): MaybeAsync<void>\n    /**\n     * Get default datacenter for this session\n     * (by default should return null)\n     */\n    getDefaultDcs(): MaybeAsync<ITelegramStorage.DcOptions | null>\n\n    /**\n     * Get auth_key for a given DC\n     * (returning null will start authorization)\n     * For temp keys: should also return null if the key has expired\n     *\n     * @param dcId DC ID\n     * @param tempIndex  Index of the temporary key (usually 0, used for multi-connections)\n     */\n    getAuthKeyFor(dcId: number, tempIndex?: number): MaybeAsync<Uint8Array | null>\n    /**\n     * Set auth_key for a given DC\n     */\n    setAuthKeyFor(dcId: number, key: Uint8Array | null): MaybeAsync<void>\n    /**\n     * Set temp_auth_key for a given DC\n     * expiresAt is unix time in ms\n     */\n    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): MaybeAsync<void>\n    /**\n     * Remove all saved auth keys (both temp and perm)\n     * for the given DC. Used when perm_key becomes invalid,\n     * meaning all temp_keys also become invalid\n     */\n    dropAuthKeysFor(dcId: number): MaybeAsync<void>\n\n    /**\n     * Get information about currently logged in user (if available)\n     */\n    getSelf(): MaybeAsync<ITelegramStorage.SelfInfo | null>\n    /**\n     * Save information about currently logged in user\n     */\n    setSelf(self: ITelegramStorage.SelfInfo | null): MaybeAsync<void>\n\n    /**\n     * Update local database of input peers from the peer info list\n     */\n    updatePeers(peers: ITelegramStorage.PeerInfo[]): MaybeAsync<void>\n    /**\n     * Find a peer in local database by its marked ID\n     */\n    getPeerById(peerId: number): MaybeAsync<tl.TypeInputPeer | null>\n    /**\n     * Find a peer in local database by its username\n     */\n    getPeerByUsername(username: string): MaybeAsync<tl.TypeInputPeer | null>\n    /**\n     * Find a peer in local database by its phone number\n     */\n    getPeerByPhone(phone: string): MaybeAsync<tl.TypeInputPeer | null>\n\n    /**\n     * Get updates state (if available), represented as a tuple\n     * containing: `pts, qts, date, seq`\n     */\n    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>\n\n    /**\n     * Set common `pts` value\n     */\n    setUpdatesPts(val: number): MaybeAsync<void>\n    /**\n     * Set common `qts` value\n     */\n    setUpdatesQts(val: number): MaybeAsync<void>\n    /**\n     * Set updates `date` value\n     */\n    setUpdatesDate(val: number): MaybeAsync<void>\n    /**\n     * Set updates `seq` value\n     */\n    setUpdatesSeq(val: number): MaybeAsync<void>\n\n    /**\n     * Get channel `pts` value\n     */\n    getChannelPts(entityId: number): MaybeAsync<number | null>\n    /**\n     * Set channels `pts` values in batch.\n     * Storage is supposed to replace stored channel `pts` values\n     * with given in the object (key is unmarked peer id, value is the `pts`)\n     */\n    setManyChannelPts(values: Map<number, number>): MaybeAsync<void>\n\n    /**\n     * Get cached peer information by their marked ID.\n     * Return `null` if caching is not supported, or the entity\n     * is not cached (yet).\n     *\n     * This is primarily used when a `min` entity is encountered\n     * in an update, or when a *short* update is encountered.\n     * Returning `null` will require re-fetching that\n     * update with the peers added, which might not be very efficient.\n     */\n    getFullPeerById(id: number): MaybeAsync<tl.TypeUser | tl.TypeChat | null>\n}\n"]}

package/cjs/storage/index.d.ts

@@ -0,0 +1,5 @@
+export * from './abstract.js';
+export * from './json.js';
+export * from './json-file.js';
+export * from './localstorage.js';
+export * from './memory.js';

package/cjs/storage/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract.js"), exports);
+__exportStar(require("./json.js"), exports);
+__exportStar(require("./json-file.js"), exports);
+__exportStar(require("./localstorage.js"), exports);
+__exportStar(require("./memory.js"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA6B;AAC7B,4CAAyB;AACzB,iDAA8B;AAC9B,oDAAiC;AACjC,8CAA2B","sourcesContent":["export * from './abstract.js'\nexport * from './json.js'\nexport * from './json-file.js'\nexport * from './localstorage.js'\nexport * from './memory.js'\n"]}

package/cjs/storage/json-file.d.ts

@@ -0,0 +1,31 @@
+import { JsonMemoryStorage } from './json.js';
+export declare class JsonFileStorage extends JsonMemoryStorage {
+    private readonly _filename;
+    private readonly _safe;
+    private readonly _cleanup;
+    constructor(filename: string, params?: {
+        /**
+         * Whether to save file "safely", meaning that the file will first be saved
+         * to `${filename}.tmp`, and then renamed to `filename`,
+         * instead of writing directly to `filename`.
+         *
+         * This solves the issue with the storage being saved as
+         * a blank file because of the app being stopped while
+         * the storage is being written.
+         *
+         * @default  `true`
+         */
+        safe?: boolean;
+        /**
+         * Whether to save file on process exit.
+         *
+         * @default  `true`
+         */
+        cleanup?: boolean;
+    });
+    load(): Promise<void>;
+    save(): Promise<void>;
+    private _processExitHandled;
+    private _onProcessExit;
+    destroy(): void;
+}

package/cjs/storage/json-file.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileStorage = void 0;
+// eslint-disable-next-line no-restricted-imports
+const fs = __importStar(require("fs"));
+const json_js_1 = require("./json.js");
+const EVENTS = ['exit', 'SIGINT', 'SIGUSR1', 'SIGUSR2', 'uncaughtException', 'SIGTERM'];
+class JsonFileStorage extends json_js_1.JsonMemoryStorage {
+    constructor(filename, params) {
+        super();
+        this._processExitHandled = false;
+        this._filename = filename;
+        this._safe = params?.safe ?? true;
+        this._cleanup = params?.cleanup ?? true;
+        if (this._cleanup) {
+            this._onProcessExit = this._onProcessExit.bind(this);
+            EVENTS.forEach((event) => process.on(event, this._onProcessExit));
+        }
+    }
+    async load() {
+        try {
+            this._loadJson(await new Promise((res, rej) => fs.readFile(this._filename, 'utf-8', (err, data) => (err ? rej(err) : res(data)))));
+        }
+        catch (e) { }
+    }
+    save() {
+        return new Promise((resolve, reject) => {
+            fs.writeFile(this._safe ? this._filename + '.tmp' : this._filename, this._saveJson(), (err) => {
+                if (err)
+                    reject(err);
+                else if (this._safe) {
+                    fs.rename(this._filename + '.tmp', this._filename, (err) => {
+                        if (err && err.code !== 'ENOENT')
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                }
+                else
+                    resolve();
+            });
+        });
+    }
+    _onProcessExit() {
+        // on exit handler must be synchronous, thus we use sync methods here
+        if (this._processExitHandled)
+            return;
+        this._processExitHandled = true;
+        try {
+            fs.writeFileSync(this._filename, this._saveJson());
+        }
+        catch (e) { }
+        if (this._safe) {
+            try {
+                fs.unlinkSync(this._filename + '.tmp');
+            }
+            catch (e) { }
+        }
+    }
+    destroy() {
+        if (this._cleanup) {
+            EVENTS.forEach((event) => process.off(event, this._onProcessExit));
+        }
+    }
+}
+exports.JsonFileStorage = JsonFileStorage;
+//# sourceMappingURL=json-file.js.map

package/cjs/storage/json-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-file.js","sourceRoot":"","sources":["../../../src/storage/json-file.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line no-restricted-imports\nimport * as fs from 'fs'\n\nimport { JsonMemoryStorage } from './json.js'\n\nconst EVENTS = ['exit', 'SIGINT', 'SIGUSR1', 'SIGUSR2', 'uncaughtException', 'SIGTERM']\n\nexport class JsonFileStorage extends JsonMemoryStorage {\n    private readonly _filename: string\n    private readonly _safe: boolean\n    private readonly _cleanup: boolean\n\n    constructor(\n        filename: string,\n        params?: {\n            /**\n             * Whether to save file \"safely\", meaning that the file will first be saved\n             * to `${filename}.tmp`, and then renamed to `filename`,\n             * instead of writing directly to `filename`.\n             *\n             * This solves the issue with the storage being saved as\n             * a blank file because of the app being stopped while\n             * the storage is being written.\n             *\n             * @default  `true`\n             */\n            safe?: boolean\n\n            /**\n             * Whether to save file on process exit.\n             *\n             * @default  `true`\n             */\n            cleanup?: boolean\n        },\n    ) {\n        super()\n\n        this._filename = filename\n        this._safe = params?.safe ?? true\n        this._cleanup = params?.cleanup ?? true\n\n        if (this._cleanup) {\n            this._onProcessExit = this._onProcessExit.bind(this)\n            EVENTS.forEach((event) => process.on(event, this._onProcessExit))\n        }\n    }\n\n    async load(): Promise<void> {\n        try {\n            this._loadJson(\n                await new Promise((res, rej) =>\n                    fs.readFile(this._filename, 'utf-8', (err, data) => (err ? rej(err) : res(data))),\n                ),\n            )\n        } catch (e) {}\n    }\n\n    save(): Promise<void> {\n        return new Promise((resolve, reject) => {\n            fs.writeFile(this._safe ? this._filename + '.tmp' : this._filename, this._saveJson(), (err) => {\n                if (err) reject(err)\n                else if (this._safe) {\n                    fs.rename(this._filename + '.tmp', this._filename, (err) => {\n                        if (err && err.code !== 'ENOENT') reject(err)\n                        else resolve()\n                    })\n                } else resolve()\n            })\n        })\n    }\n\n    private _processExitHandled = false\n    private _onProcessExit(): void {\n        // on exit handler must be synchronous, thus we use sync methods here\n        if (this._processExitHandled) return\n        this._processExitHandled = true\n\n        try {\n            fs.writeFileSync(this._filename, this._saveJson())\n        } catch (e) {}\n\n        if (this._safe) {\n            try {\n                fs.unlinkSync(this._filename + '.tmp')\n            } catch (e) {}\n        }\n    }\n\n    destroy(): void {\n        if (this._cleanup) {\n            EVENTS.forEach((event) => process.off(event, this._onProcessExit))\n        }\n    }\n}\n"]}

package/cjs/storage/json.d.ts

@@ -0,0 +1,9 @@
+import { MemoryStorage } from './memory.js';
+/**
+ * Helper class that provides json serialization functions
+ * to the session.
+ */
+export declare class JsonMemoryStorage extends MemoryStorage {
+    protected _loadJson(json: string): void;
+    protected _saveJson(): string;
+}

package/cjs/storage/json.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonMemoryStorage = void 0;
+const tl_runtime_1 = require("@mtcute/tl-runtime");
+const long_utils_js_1 = require("../utils/long-utils.js");
+const memory_js_1 = require("./memory.js");
+/**
+ * Helper class that provides json serialization functions
+ * to the session.
+ */
+class JsonMemoryStorage extends memory_js_1.MemoryStorage {
+    _loadJson(json) {
+        this._setStateFrom(JSON.parse(json, (key, value) => {
+            switch (key) {
+                case 'authKeys':
+                case 'authKeysTemp': {
+                    const ret = {};
+                    value.split('|').forEach((pair) => {
+                        const [dcId, b64] = pair.split(',');
+                        ret[dcId] = (0, tl_runtime_1.base64DecodeToBuffer)(b64);
+                    });
+                    return ret;
+                }
+                case 'authKeysTempExpiry':
+                case 'entities':
+                case 'phoneIndex':
+                case 'usernameIndex':
+                case 'pts':
+                case 'fsm':
+                case 'rl':
+                    return new Map(Object.entries(value));
+                case 'accessHash':
+                    return (0, long_utils_js_1.longFromFastString)(value);
+            }
+            return value;
+        }));
+    }
+    _saveJson() {
+        return JSON.stringify(this._state, (key, value) => {
+            switch (key) {
+                case 'authKeys':
+                case 'authKeysTemp': {
+                    const value_ = value;
+                    return [...value_.entries()]
+                        .filter((it) => it[1] !== null)
+                        .map(([dcId, key]) => dcId + ',' + (0, tl_runtime_1.base64Encode)(key))
+                        .join('|');
+                }
+                case 'authKeysTempExpiry':
+                case 'entities':
+                case 'phoneIndex':
+                case 'usernameIndex':
+                case 'pts':
+                case 'fsm':
+                case 'rl':
+                    return Object.fromEntries([...value.entries()]);
+                case 'accessHash':
+                    return (0, long_utils_js_1.longToFastString)(value);
+            }
+            return value;
+        });
+    }
+}
+exports.JsonMemoryStorage = JsonMemoryStorage;
+//# sourceMappingURL=json.js.map

package/cjs/storage/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../src/storage/json.ts"],"names":[],"mappings":";;;AAEA,mDAAuE;AAEvE,0DAA6E;AAC7E,2CAA+D;AAE/D;;;GAGG;AACH,MAAa,iBAAkB,SAAQ,yBAAa;IACtC,SAAS,CAAC,IAAY;QAC5B,IAAI,CAAC,aAAa,CACd,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;YAC5B,QAAQ,GAAG,EAAE;gBACT,KAAK,UAAU,CAAC;gBAChB,KAAK,cAAc,CAAC,CAAC;oBACjB,MAAM,GAAG,GAA+B,EAAE,CAEzC;oBAAC,KAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAY,EAAE,EAAE;wBACnD,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;wBACnC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAA,iCAAoB,EAAC,GAAG,CAAC,CAAA;oBACzC,CAAC,CAAC,CAAA;oBAEF,OAAO,GAAG,CAAA;iBACb;gBACD,KAAK,oBAAoB,CAAC;gBAC1B,KAAK,UAAU,CAAC;gBAChB,KAAK,YAAY,CAAC;gBAClB,KAAK,eAAe,CAAC;gBACrB,KAAK,KAAK,CAAC;gBACX,KAAK,KAAK,CAAC;gBACX,KAAK,IAAI;oBACL,OAAO,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAA+B,CAAC,CAAC,CAAA;gBACnE,KAAK,YAAY;oBACb,OAAO,IAAA,kCAAkB,EAAC,KAAe,CAAC,CAAA;aACjD;YAED,OAAO,KAAK,CAAA;QAChB,CAAC,CAAuB,CAC3B,CAAA;IACL,CAAC;IAES,SAAS;QACf,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;YAC9C,QAAQ,GAAG,EAAE;gBACT,KAAK,UAAU,CAAC;gBAChB,KAAK,cAAc,CAAC,CAAC;oBACjB,MAAM,MAAM,GAAG,KAAuC,CAAA;oBAEtD,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;yBACvB,MAAM,CAAC,CAAC,EAAE,EAA8B,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;yBAC1D,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,GAAG,IAAA,yBAAY,EAAC,GAAG,CAAC,CAAC;yBACpD,IAAI,CAAC,GAAG,CAAC,CAAA;iBACjB;gBACD,KAAK,oBAAoB,CAAC;gBAC1B,KAAK,UAAU,CAAC;gBAChB,KAAK,YAAY,CAAC;gBAClB,KAAK,eAAe,CAAC;gBACrB,KAAK,KAAK,CAAC;gBACX,KAAK,KAAK,CAAC;gBACX,KAAK,IAAI;oBACL,OAAO,MAAM,CAAC,WAAW,CAAC,CAAC,GAAI,KAA6B,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;gBAC5E,KAAK,YAAY;oBACb,OAAO,IAAA,gCAAgB,EAAC,KAAgB,CAAC,CAAA;aAChD;YAED,OAAO,KAAK,CAAA;QAChB,CAAC,CAAC,CAAA;IACN,CAAC;CACJ;AA5DD,8CA4DC","sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-return */\nimport { tl } from '@mtcute/tl'\nimport { base64DecodeToBuffer, base64Encode } from '@mtcute/tl-runtime'\n\nimport { longFromFastString, longToFastString } from '../utils/long-utils.js'\nimport { MemorySessionState, MemoryStorage } from './memory.js'\n\n/**\n * Helper class that provides json serialization functions\n * to the session.\n */\nexport class JsonMemoryStorage extends MemoryStorage {\n    protected _loadJson(json: string): void {\n        this._setStateFrom(\n            JSON.parse(json, (key, value) => {\n                switch (key) {\n                    case 'authKeys':\n                    case 'authKeysTemp': {\n                        const ret: Record<string, Uint8Array> = {}\n\n                        ;(value as string).split('|').forEach((pair: string) => {\n                            const [dcId, b64] = pair.split(',')\n                            ret[dcId] = base64DecodeToBuffer(b64)\n                        })\n\n                        return ret\n                    }\n                    case 'authKeysTempExpiry':\n                    case 'entities':\n                    case 'phoneIndex':\n                    case 'usernameIndex':\n                    case 'pts':\n                    case 'fsm':\n                    case 'rl':\n                        return new Map(Object.entries(value as Record<string, string>))\n                    case 'accessHash':\n                        return longFromFastString(value as string)\n                }\n\n                return value\n            }) as MemorySessionState,\n        )\n    }\n\n    protected _saveJson(): string {\n        return JSON.stringify(this._state, (key, value) => {\n            switch (key) {\n                case 'authKeys':\n                case 'authKeysTemp': {\n                    const value_ = value as Map<string, Uint8Array | null>\n\n                    return [...value_.entries()]\n                        .filter((it): it is [string, Uint8Array] => it[1] !== null)\n                        .map(([dcId, key]) => dcId + ',' + base64Encode(key))\n                        .join('|')\n                }\n                case 'authKeysTempExpiry':\n                case 'entities':\n                case 'phoneIndex':\n                case 'usernameIndex':\n                case 'pts':\n                case 'fsm':\n                case 'rl':\n                    return Object.fromEntries([...(value as Map<string, string>).entries()])\n                case 'accessHash':\n                    return longToFastString(value as tl.Long)\n            }\n\n            return value\n        })\n    }\n}\n"]}

package/cjs/storage/localstorage.d.ts

@@ -0,0 +1,7 @@
+import { JsonMemoryStorage } from './json.js';
+export declare class LocalstorageStorage extends JsonMemoryStorage {
+    private readonly _key;
+    constructor(key: string);
+    load(): void;
+    save(): void;
+}

package/cjs/storage/localstorage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalstorageStorage = void 0;
+const index_js_1 = require("../types/index.js");
+const json_js_1 = require("./json.js");
+class LocalstorageStorage extends json_js_1.JsonMemoryStorage {
+    constructor(key) {
+        super();
+        if (typeof localStorage === 'undefined') {
+            throw new index_js_1.MtUnsupportedError('localStorage is not available!');
+        }
+        this._key = key;
+    }
+    load() {
+        try {
+            this._loadJson(localStorage[this._key]);
+        }
+        catch (e) { }
+    }
+    save() {
+        localStorage[this._key] = this._saveJson();
+    }
+}
+exports.LocalstorageStorage = LocalstorageStorage;
+//# sourceMappingURL=localstorage.js.map

package/cjs/storage/localstorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localstorage.js","sourceRoot":"","sources":["../../../src/storage/localstorage.ts"],"names":[],"mappings":";;;AAAA,gDAAsD;AACtD,uCAA6C;AAE7C,MAAa,mBAAoB,SAAQ,2BAAiB;IAGtD,YAAY,GAAW;QACnB,KAAK,EAAE,CAAA;QAEP,IAAI,OAAO,YAAY,KAAK,WAAW,EAAE;YACrC,MAAM,IAAI,6BAAkB,CAAC,gCAAgC,CAAC,CAAA;SACjE;QAED,IAAI,CAAC,IAAI,GAAG,GAAG,CAAA;IACnB,CAAC;IAED,IAAI;QACA,IAAI;YACA,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAW,CAAC,CAAA;SACpD;QAAC,OAAO,CAAC,EAAE,GAAE;IAClB,CAAC;IAED,IAAI;QACA,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;IAC9C,CAAC;CACJ;AAtBD,kDAsBC","sourcesContent":["import { MtUnsupportedError } from '../types/index.js'\nimport { JsonMemoryStorage } from './json.js'\n\nexport class LocalstorageStorage extends JsonMemoryStorage {\n    private readonly _key: string\n\n    constructor(key: string) {\n        super()\n\n        if (typeof localStorage === 'undefined') {\n            throw new MtUnsupportedError('localStorage is not available!')\n        }\n\n        this._key = key\n    }\n\n    load(): void {\n        try {\n            this._loadJson(localStorage[this._key] as string)\n        } catch (e) {}\n    }\n\n    save(): void {\n        localStorage[this._key] = this._saveJson()\n    }\n}\n"]}

package/cjs/storage/memory.d.ts

@@ -0,0 +1,98 @@
+import { tl } from '@mtcute/tl';
+import { MaybeAsync } from '../types/index.js';
+import { ITelegramStorage } from './abstract.js';
+declare const CURRENT_VERSION = 1;
+type PeerInfoWithUpdated = ITelegramStorage.PeerInfo & {
+    updated: number;
+};
+export interface MemorySessionState {
+    $version: typeof CURRENT_VERSION;
+    defaultDcs: ITelegramStorage.DcOptions | null;
+    authKeys: Map<number, Uint8Array>;
+    authKeysTemp: Map<string, Uint8Array>;
+    authKeysTempExpiry: Map<string, number>;
+    entities: Map<number, PeerInfoWithUpdated>;
+    phoneIndex: Map<string, number>;
+    usernameIndex: Map<string, number>;
+    gpts: [number, number, number, number] | null;
+    pts: Map<number, number>;
+    fsm: Map<string, {
+        v: unknown;
+        e?: number;
+    }>;
+    rl: Map<string, {
+        res: number;
+        rem: number;
+    }>;
+    self: ITelegramStorage.SelfInfo | null;
+}
+export declare class MemoryStorage implements ITelegramStorage {
+    protected _state: MemorySessionState;
+    private _cachedInputPeers;
+    private _cachedFull;
+    private _vacuumTimeout?;
+    private _vacuumInterval;
+    constructor(params?: {
+        /**
+         * Maximum number of cached full entities.
+         *
+         * Note that full entities are **NOT** persisted
+         * to the disk (in case this storage is backed
+         * by a local storage), and only available within
+         * the current runtime.
+         *
+         * @default  `100`, use `0` to disable
+         */
+        cacheSize?: number;
+        /**
+         * Interval in milliseconds for vacuuming the storage.
+         *
+         * When vacuuming, the storage will remove expired FSM
+         * states to reduce memory usage.
+         *
+         * @default  `300_000` (5 minutes)
+         */
+        vacuumInterval?: number;
+    });
+    load(): void;
+    destroy(): void;
+    reset(): void;
+    /**
+     * Set a given object as an underlying state.
+     *
+     * Note that this object will be used as-is, so if
+     * you plan on using it somewhere else, be sure to copy it beforehand.
+     */
+    protected _setStateFrom(obj: MemorySessionState): void;
+    private _vacuum;
+    getDefaultDcs(): ITelegramStorage.DcOptions | null;
+    setDefaultDcs(dcs: ITelegramStorage.DcOptions | null): void;
+    setTempAuthKeyFor(dcId: number, index: number, key: Uint8Array | null, expiresAt: number): void;
+    setAuthKeyFor(dcId: number, key: Uint8Array | null): void;
+    getAuthKeyFor(dcId: number, tempIndex?: number): Uint8Array | null;
+    dropAuthKeysFor(dcId: number): void;
+    updatePeers(peers: PeerInfoWithUpdated[]): MaybeAsync<void>;
+    protected _getInputPeer(peerInfo?: ITelegramStorage.PeerInfo): tl.TypeInputPeer | null;
+    getPeerById(peerId: number): tl.TypeInputPeer | null;
+    getPeerByPhone(phone: string): tl.TypeInputPeer | null;
+    getPeerByUsername(username: string): tl.TypeInputPeer | null;
+    getSelf(): ITelegramStorage.SelfInfo | null;
+    setSelf(self: ITelegramStorage.SelfInfo | null): void;
+    setManyChannelPts(values: Map<number, number>): void;
+    getChannelPts(entityId: number): number | null;
+    getUpdatesState(): MaybeAsync<[number, number, number, number] | null>;
+    setUpdatesPts(val: number): MaybeAsync<void>;
+    setUpdatesQts(val: number): MaybeAsync<void>;
+    setUpdatesDate(val: number): MaybeAsync<void>;
+    setUpdatesSeq(val: number): MaybeAsync<void>;
+    getFullPeerById(id: number): tl.TypeUser | tl.TypeChat | null;
+    getState(key: string): unknown;
+    setState(key: string, state: unknown, ttl?: number): void;
+    deleteState(key: string): void;
+    getCurrentScene(key: string): string | null;
+    setCurrentScene(key: string, scene: string, ttl?: number): void;
+    deleteCurrentScene(key: string): void;
+    getRateLimit(key: string, limit: number, window: number): [number, number];
+    resetRateLimit(key: string): void;
+}
+export {};