sroosh 1.0.0

package/sessions/CacheApiSession.js

@@ -0,0 +1,99 @@
+"use strict";
+const MemorySession = require("./Memory");
+const AuthKey = require("../crypto/AuthKey");
+const utils = require("../Utils");
+const CACHE_NAME = "GramJs";
+const STORAGE_KEY_BASE = "GramJs-session-";
+class CacheApi extends MemorySession {
+    constructor(sessionId) {
+        super();
+        this._storageKey = sessionId;
+        this._authKeys = {};
+    }
+    async load() {
+        if (!this._storageKey) {
+            return;
+        }
+        try {
+            const json = await fetchFromCache(this._storageKey);
+            const { mainDcId, keys, hashes } = JSON.parse(json);
+            const { ipAddress, port } = await utils.getDC(mainDcId);
+            this.setDC(mainDcId, ipAddress, port, true);
+            Object.keys(keys).forEach((dcId) => {
+                if (keys[dcId] && hashes[dcId]) {
+                    this._authKeys[dcId] = new AuthKey(Buffer.from(keys[dcId].data), Buffer.from(hashes[dcId].data));
+                }
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to retrieve or parse JSON from Cache for key ${this._storageKey}`);
+        }
+    }
+    setDC(dcId, serverAddress, port, skipUpdateStorage = false) {
+        this._dcId = dcId;
+        this._serverAddress = serverAddress;
+        this._port = port;
+        delete this._authKeys[dcId];
+        if (!skipUpdateStorage) {
+            void this._updateStorage();
+        }
+    }
+    async save() {
+        if (!this._storageKey) {
+            this._storageKey = generateStorageKey();
+        }
+        await this._updateStorage();
+        return this._storageKey;
+    }
+    get authKey() {
+        throw new Error("Not supported");
+    }
+    set authKey(value) {
+        throw new Error("Not supported");
+    }
+    getAuthKey(dcId = this._dcId) {
+        return this._authKeys[dcId];
+    }
+    setAuthKey(authKey, dcId = this._dcId) {
+        this._authKeys[dcId] = authKey;
+        void this._updateStorage();
+    }
+    async _updateStorage() {
+        if (!this._storageKey) {
+            return;
+        }
+        const sessionData = {
+            mainDcId: this._dcId,
+            keys: {},
+            hashes: {},
+        };
+        Object.keys(this._authKeys).map((dcId) => {
+            const authKey = this._authKeys[dcId];
+            sessionData.keys[dcId] = authKey._key;
+            sessionData.hashes[dcId] = authKey._hash;
+        });
+        await saveToCache(this._storageKey, JSON.stringify(sessionData));
+    }
+    async delete() {
+        const request = new Request(this._storageKey);
+        const cache = await self.caches.open(CACHE_NAME);
+        await cache.delete(request);
+    }
+}
+function generateStorageKey() {
+    // Creating two sessions at the same moment is not expected nor supported.
+    return `${STORAGE_KEY_BASE}${Date.now()}`;
+}
+async function fetchFromCache(key) {
+    const request = new Request(key);
+    const cache = await self.caches.open(CACHE_NAME);
+    const cached = await cache.match(request);
+    return cached ? cached.text() : null;
+}
+async function saveToCache(key, data) {
+    const request = new Request(key);
+    const response = new Response(data);
+    const cache = await self.caches.open(CACHE_NAME);
+    return cache.put(request, response);
+}
+module.exports = CacheApi;

package/sessions/Memory.d.ts

@@ -0,0 +1,38 @@
+import { Session } from "./Abstract";
+import type { AuthKey } from "../crypto/AuthKey";
+import { Api } from "../tl";
+import bigInt from "big-integer";
+import type { EntityLike } from "../define";
+export declare class MemorySession extends Session {
+    protected _serverAddress?: string;
+    protected _dcId: number;
+    protected _port?: number;
+    protected _takeoutId: undefined;
+    protected _entities: Set<any>;
+    protected _updateStates: {};
+    protected _authKey?: AuthKey;
+    constructor();
+    setDC(dcId: number, serverAddress: string, port: number): void;
+    get dcId(): number;
+    get serverAddress(): string;
+    get port(): number;
+    get authKey(): AuthKey | undefined;
+    set authKey(value: AuthKey | undefined);
+    get takeoutId(): undefined;
+    set takeoutId(value: undefined);
+    getAuthKey(dcId?: number): AuthKey | undefined;
+    setAuthKey(authKey?: AuthKey, dcId?: number): undefined;
+    close(): void;
+    save(): void;
+    load(): Promise<void>;
+    delete(): void;
+    _entityValuesToRow(id: bigInt.BigInteger | string, hash: bigInt.BigInteger | string, username: string, phone: string, name: string): (string | bigInt.BigInteger)[];
+    _entityToRow(e: any): (string | bigInt.BigInteger)[] | undefined;
+    _entitiesToRows(tlo: any): (string | bigInt.BigInteger)[][];
+    processEntities(tlo: any): void;
+    getEntityRowsByPhone(phone: string): any[] | undefined;
+    getEntityRowsByUsername(username: string): any[] | undefined;
+    getEntityRowsByName(name: string): any[] | undefined;
+    getEntityRowsById(id: string | bigInt.BigInteger, exact?: boolean): any[] | undefined;
+    getInputEntity(key: EntityLike): Api.TypeInputPeer;
+}

package/sessions/Memory.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySession = void 0;
+const Abstract_1 = require("./Abstract");
+const tl_1 = require("../tl");
+const big_integer_1 = __importDefault(require("big-integer"));
+const Utils_1 = require("../Utils");
+const Helpers_1 = require("../Helpers");
+const __1 = require("../");
+class MemorySession extends Abstract_1.Session {
+    constructor() {
+        super();
+        this._serverAddress = undefined;
+        this._dcId = 0;
+        this._port = undefined;
+        this._takeoutId = undefined;
+        this._entities = new Set();
+        this._updateStates = {};
+    }
+    setDC(dcId, serverAddress, port) {
+        this._dcId = dcId | 0;
+        this._serverAddress = serverAddress;
+        this._port = port;
+    }
+    get dcId() {
+        return this._dcId;
+    }
+    get serverAddress() {
+        return this._serverAddress;
+    }
+    get port() {
+        return this._port;
+    }
+    get authKey() {
+        return this._authKey;
+    }
+    set authKey(value) {
+        this._authKey = value;
+    }
+    get takeoutId() {
+        return this._takeoutId;
+    }
+    set takeoutId(value) {
+        this._takeoutId = value;
+    }
+    getAuthKey(dcId) {
+        if (dcId && dcId !== this.dcId) {
+            // Not supported.
+            return undefined;
+        }
+        return this.authKey;
+    }
+    setAuthKey(authKey, dcId) {
+        if (dcId && dcId !== this.dcId) {
+            // Not supported.
+            return undefined;
+        }
+        this.authKey = authKey;
+    }
+    close() { }
+    save() { }
+    async load() { }
+    delete() { }
+    _entityValuesToRow(id, hash, username, phone, name) {
+        // While this is a simple implementation it might be overrode by,
+        // other classes so they don't need to implement the plural form
+        // of the method. Don't remove.
+        return [id, hash, username, phone, name];
+    }
+    _entityToRow(e) {
+        if (!(e.classType === "constructor")) {
+            return;
+        }
+        let p;
+        let markedId;
+        try {
+            p = (0, Utils_1.getInputPeer)(e, false);
+            markedId = (0, Utils_1.getPeerId)(p);
+        }
+        catch (e) {
+            return;
+        }
+        let pHash;
+        if (p instanceof tl_1.Api.InputPeerUser ||
+            p instanceof tl_1.Api.InputPeerChannel) {
+            pHash = p.accessHash;
+        }
+        else if (p instanceof tl_1.Api.InputPeerChat) {
+            pHash = big_integer_1.default.zero;
+        }
+        else {
+            return;
+        }
+        let username = e.username;
+        if (username) {
+            username = username.toLowerCase();
+        }
+        const phone = e.phone;
+        const name = (0, Utils_1.getDisplayName)(e);
+        return this._entityValuesToRow(markedId, pHash, username, phone, name);
+    }
+    _entitiesToRows(tlo) {
+        let entities = [];
+        if (!(tlo.classType === "constructor") && (0, Helpers_1.isArrayLike)(tlo)) {
+            // This may be a list of users already for instance
+            entities = tlo;
+        }
+        else {
+            if (typeof tlo === "object") {
+                if ("user" in tlo) {
+                    entities.push(tlo.user);
+                }
+                if ("chat" in tlo) {
+                    entities.push(tlo.chat);
+                }
+                if ("channel" in tlo) {
+                    entities.push(tlo.channel);
+                }
+                if ("chats" in tlo && (0, Helpers_1.isArrayLike)(tlo.chats)) {
+                    entities = entities.concat(tlo.chats);
+                }
+                if ("users" in tlo && (0, Helpers_1.isArrayLike)(tlo.users)) {
+                    entities = entities.concat(tlo.users);
+                }
+            }
+        }
+        const rows = []; // Rows to add (id, hash, username, phone, name)
+        for (const e of entities) {
+            const row = this._entityToRow(e);
+            if (row) {
+                rows.push(row);
+            }
+        }
+        return rows;
+    }
+    processEntities(tlo) {
+        const entitiesSet = this._entitiesToRows(tlo);
+        for (const e of entitiesSet) {
+            this._entities.add(e);
+        }
+    }
+    getEntityRowsByPhone(phone) {
+        for (const e of this._entities) {
+            // id, hash, username, phone, name
+            if (e[3] === phone) {
+                return [e[0], e[1]];
+            }
+        }
+    }
+    getEntityRowsByUsername(username) {
+        for (const e of this._entities) {
+            // id, hash, username, phone, name
+            if (e[2] === username) {
+                return [e[0], e[1]];
+            }
+        }
+    }
+    getEntityRowsByName(name) {
+        for (const e of this._entities) {
+            // id, hash, username, phone, name
+            if (e[4] === name) {
+                return [e[0], e[1]];
+            }
+        }
+    }
+    getEntityRowsById(id, exact = true) {
+        if (exact) {
+            for (const e of this._entities) {
+                // id, hash, username, phone, name
+                if (e[0] === id) {
+                    return [e[0], e[1]];
+                }
+            }
+        }
+        else {
+            const ids = [
+                __1.utils.getPeerId(new tl_1.Api.PeerUser({ userId: (0, Helpers_1.returnBigInt)(id) })),
+                __1.utils.getPeerId(new tl_1.Api.PeerChat({ chatId: (0, Helpers_1.returnBigInt)(id) })),
+                __1.utils.getPeerId(new tl_1.Api.PeerChannel({ channelId: (0, Helpers_1.returnBigInt)(id) })),
+            ];
+            for (const e of this._entities) {
+                // id, hash, username, phone, name
+                if (ids.includes(e[0])) {
+                    return [e[0], e[1]];
+                }
+            }
+        }
+    }
+    getInputEntity(key) {
+        let exact;
+        if (typeof key === "object" &&
+            !big_integer_1.default.isInstance(key) &&
+            key.SUBCLASS_OF_ID) {
+            if (key.SUBCLASS_OF_ID == 0xc91c90b6 ||
+                key.SUBCLASS_OF_ID == 0xe669bf46 ||
+                key.SUBCLASS_OF_ID == 0x40f202fd) {
+                // @ts-ignore
+                return key;
+            }
+            // Try to early return if this key can be casted as input peer
+            return __1.utils.getInputPeer(key);
+        }
+        else {
+            // Not a TLObject or can't be cast into InputPeer
+            if (typeof key === "object") {
+                key = __1.utils.getPeerId(key);
+                exact = true;
+            }
+            else {
+                exact = false;
+            }
+        }
+        if (big_integer_1.default.isInstance(key) ||
+            typeof key == "bigint" ||
+            typeof key == "number") {
+            key = key.toString();
+        }
+        let result = undefined;
+        if (typeof key === "string") {
+            const phone = __1.utils.parsePhone(key);
+            if (phone) {
+                result = this.getEntityRowsByPhone(phone);
+            }
+            else {
+                const { username, isInvite } = __1.utils.parseUsername(key);
+                if (username && !isInvite) {
+                    result = this.getEntityRowsByUsername(username);
+                }
+            }
+            if (!result) {
+                const id = __1.utils.parseID(key);
+                if (id) {
+                    result = this.getEntityRowsById(id, exact);
+                }
+            }
+            if (!result) {
+                result = this.getEntityRowsByName(key);
+            }
+        }
+        if (result) {
+            let entityId = result[0]; // unpack resulting tuple
+            const entityHash = (0, big_integer_1.default)(result[1]);
+            const resolved = __1.utils.resolveId((0, Helpers_1.returnBigInt)(entityId));
+            entityId = resolved[0];
+            const kind = resolved[1];
+            // removes the mark and returns type of entity
+            if (kind === tl_1.Api.PeerUser) {
+                return new tl_1.Api.InputPeerUser({
+                    userId: entityId,
+                    accessHash: entityHash,
+                });
+            }
+            else if (kind === tl_1.Api.PeerChat) {
+                return new tl_1.Api.InputPeerChat({ chatId: entityId });
+            }
+            else if (kind === tl_1.Api.PeerChannel) {
+                return new tl_1.Api.InputPeerChannel({
+                    channelId: entityId,
+                    accessHash: entityHash,
+                });
+            }
+        }
+        else {
+            throw new Error("Could not find input entity with key " + key);
+        }
+        throw new Error("Could not find input entity with key " + key);
+    }
+}
+exports.MemorySession = MemorySession;

package/sessions/StoreSession.d.ts

@@ -0,0 +1,14 @@
+import { MemorySession } from "./Memory";
+import { AuthKey } from "../crypto/AuthKey";
+import bigInt from "big-integer";
+export declare class StoreSession extends MemorySession {
+    private readonly sessionName;
+    private store;
+    constructor(sessionName: string, divider?: string);
+    load(): Promise<void>;
+    setDC(dcId: number, serverAddress: string, port: number): void;
+    set authKey(value: AuthKey | undefined);
+    get authKey(): AuthKey | undefined;
+    processEntities(tlo: any): void;
+    getEntityRowsById(id: string | bigInt.BigInteger, exact?: boolean): any;
+}

package/sessions/StoreSession.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreSession = void 0;
+const Memory_1 = require("./Memory");
+const store2_1 = __importDefault(require("store2"));
+const AuthKey_1 = require("../crypto/AuthKey");
+class StoreSession extends Memory_1.MemorySession {
+    constructor(sessionName, divider = ":") {
+        super();
+        if (sessionName === "session") {
+            throw new Error("Session name can't be 'session'. Please use a different name.");
+        }
+        if (typeof localStorage === "undefined" || localStorage === null) {
+            const LocalStorage = require("./localStorage").LocalStorage;
+            this.store = store2_1.default.area(sessionName, new LocalStorage("./" + sessionName));
+        }
+        else {
+            this.store = store2_1.default.area(sessionName, localStorage);
+        }
+        if (divider == undefined) {
+            divider = ":";
+        }
+        this.sessionName = sessionName + divider;
+    }
+    async load() {
+        let authKey = this.store.get(this.sessionName + "authKey");
+        if (authKey && typeof authKey === "object") {
+            this._authKey = new AuthKey_1.AuthKey();
+            if ("data" in authKey) {
+                authKey = Buffer.from(authKey.data);
+            }
+            await this._authKey.setKey(authKey);
+        }
+        const dcId = this.store.get(this.sessionName + "dcId");
+        if (dcId) {
+            this._dcId = dcId;
+        }
+        const port = this.store.get(this.sessionName + "port");
+        if (port) {
+            this._port = port;
+        }
+        const serverAddress = this.store.get(this.sessionName + "serverAddress");
+        if (serverAddress) {
+            this._serverAddress = serverAddress;
+        }
+    }
+    setDC(dcId, serverAddress, port) {
+        this.store.set(this.sessionName + "dcId", dcId);
+        this.store.set(this.sessionName + "port", port);
+        this.store.set(this.sessionName + "serverAddress", serverAddress);
+        super.setDC(dcId, serverAddress, port);
+    }
+    set authKey(value) {
+        this._authKey = value;
+        this.store.set(this.sessionName + "authKey", value === null || value === void 0 ? void 0 : value.getKey());
+    }
+    get authKey() {
+        return this._authKey;
+    }
+    processEntities(tlo) {
+        const rows = this._entitiesToRows(tlo);
+        if (!rows) {
+            return;
+        }
+        for (const row of rows) {
+            row.push(new Date().getTime().toString());
+            this.store.set(this.sessionName + row[0], row);
+        }
+    }
+    getEntityRowsById(id, exact = true) {
+        return this.store.get(this.sessionName + id.toString());
+    }
+}
+exports.StoreSession = StoreSession;

package/sessions/StringSession.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { MemorySession } from "./Memory";
+export declare class StringSession extends MemorySession {
+    _key?: Buffer;
+    /**
+     * This session file can be easily saved and loaded as a string. According
+     * to the initial design, it contains only the data that is necessary for
+     * successful connection and authentication, so takeout ID is not stored.
+
+     * It is thought to be used where you don't want to create any on-disk
+     * files but would still like to be able to save and load existing sessions
+     * by other means.
+
+     * You can use custom `encode` and `decode` functions, if present:
+
+     * `encode` definition must be ``function encode(value: Buffer) -> string:``.
+     * `decode` definition must be ``function decode(value: string) -> Buffer:``.
+     * @param session {string|null}
+     */
+    constructor(session?: string);
+    /**
+     * @param x {Buffer}
+     * @returns {string}
+     */
+    static encode(x: Buffer): string;
+    /**
+     * @param x {string}
+     * @returns {Buffer}
+     */
+    static decode(x: string): Buffer;
+    load(): Promise<void>;
+    save(): string;
+}

package/sessions/StringSession.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringSession = void 0;
+const Memory_1 = require("./Memory");
+const extensions_1 = require("../extensions");
+const AuthKey_1 = require("../crypto/AuthKey");
+const CURRENT_VERSION = "1";
+class StringSession extends Memory_1.MemorySession {
+    /**
+     * This session file can be easily saved and loaded as a string. According
+     * to the initial design, it contains only the data that is necessary for
+     * successful connection and authentication, so takeout ID is not stored.
+
+     * It is thought to be used where you don't want to create any on-disk
+     * files but would still like to be able to save and load existing sessions
+     * by other means.
+
+     * You can use custom `encode` and `decode` functions, if present:
+
+     * `encode` definition must be ``function encode(value: Buffer) -> string:``.
+     * `decode` definition must be ``function decode(value: string) -> Buffer:``.
+     * @param session {string|null}
+     */
+    constructor(session) {
+        super();
+        if (session) {
+            if (session[0] !== CURRENT_VERSION) {
+                throw new Error("Not a valid string");
+            }
+            session = session.slice(1);
+            const r = StringSession.decode(session);
+            const reader = new extensions_1.BinaryReader(r);
+            this._dcId = reader.read(1).readUInt8(0);
+            if (session.length == 352) {
+                // Telethon session
+                const ip_v4 = reader.read(4);
+                // TODO looks ugly smh
+                this._serverAddress =
+                    ip_v4[0].toString() +
+                        "." +
+                        ip_v4[1].toString() +
+                        "." +
+                        ip_v4[2].toString() +
+                        "." +
+                        ip_v4[3].toString();
+            }
+            else {
+                // TODO find a better of doing this
+                const serverAddressLen = reader.read(2).readInt16BE(0);
+                if (serverAddressLen > 100) {
+                    reader.offset -= 2;
+                    this._serverAddress = reader
+                        .read(16)
+                        .toString("hex")
+                        .match(/.{1,4}/g)
+                        .map((val) => val.replace(/^0+/, ""))
+                        .join(":")
+                        .replace(/0000\:/g, ":")
+                        .replace(/:{2,}/g, "::");
+                }
+                else {
+                    this._serverAddress = reader
+                        .read(serverAddressLen)
+                        .toString();
+                }
+            }
+            this._port = reader.read(2).readInt16BE(0);
+            this._key = reader.read(-1);
+        }
+    }
+    /**
+     * @param x {Buffer}
+     * @returns {string}
+     */
+    static encode(x) {
+        return x.toString("base64");
+    }
+    /**
+     * @param x {string}
+     * @returns {Buffer}
+     */
+    static decode(x) {
+        return Buffer.from(x, "base64");
+    }
+    async load() {
+        if (this._key) {
+            this._authKey = new AuthKey_1.AuthKey();
+            await this._authKey.setKey(this._key);
+        }
+    }
+    save() {
+        if (!this.authKey || !this.serverAddress || !this.port) {
+            return "";
+        }
+        // TS is weird
+        const key = this.authKey.getKey();
+        if (!key) {
+            return "";
+        }
+        const dcBuffer = Buffer.from([this.dcId]);
+        const addressBuffer = Buffer.from(this.serverAddress);
+        const addressLengthBuffer = Buffer.alloc(2);
+        addressLengthBuffer.writeInt16BE(addressBuffer.length, 0);
+        const portBuffer = Buffer.alloc(2);
+        portBuffer.writeInt16BE(this.port, 0);
+        return (CURRENT_VERSION +
+            StringSession.encode(Buffer.concat([
+                dcBuffer,
+                addressLengthBuffer,
+                addressBuffer,
+                portBuffer,
+                key,
+            ])));
+    }
+}
+exports.StringSession = StringSession;

package/sessions/index.d.ts

@@ -0,0 +1,4 @@
+export { MemorySession } from "./Memory";
+export { StringSession } from "./StringSession";
+export { StoreSession } from "./StoreSession";
+export { Session } from "./Abstract";

package/sessions/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = exports.StoreSession = exports.StringSession = exports.MemorySession = void 0;
+var Memory_1 = require("./Memory");
+Object.defineProperty(exports, "MemorySession", { enumerable: true, get: function () { return Memory_1.MemorySession; } });
+var StringSession_1 = require("./StringSession");
+Object.defineProperty(exports, "StringSession", { enumerable: true, get: function () { return StringSession_1.StringSession; } });
+var StoreSession_1 = require("./StoreSession");
+Object.defineProperty(exports, "StoreSession", { enumerable: true, get: function () { return StoreSession_1.StoreSession; } });
+var Abstract_1 = require("./Abstract");
+Object.defineProperty(exports, "Session", { enumerable: true, get: function () { return Abstract_1.Session; } });
+// @ts-ignore
+//export {CacheApiSession} from './CacheApiSession';

package/sessions/localStorage-BROWSER.d.ts

@@ -0,0 +1,3 @@
+export declare class LocalStorage {
+    constructor(location: string);
+}

package/sessions/localStorage-BROWSER.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+class LocalStorage {
+    constructor(location) {
+        throw new Error("Do not call me");
+    }
+}
+exports.LocalStorage = LocalStorage;

package/sessions/localStorage.d.ts

@@ -0,0 +1 @@
+export declare const LocalStorage: any;