teleproto 1.214.0

package/crypto/Factorizator.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factorizator = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const Helpers_1 = require("../Helpers");
+class Factorizator {
+    /**
+     * Calculates the greatest common divisor
+     * @param a {BigInteger}
+     * @param b {BigInteger}
+     * @returns {BigInteger}
+     */
+    static gcd(a, b) {
+        while (b.neq(big_integer_1.default.zero)) {
+            const temp = b;
+            b = a.remainder(b);
+            a = temp;
+        }
+        return a;
+    }
+    /**
+     * Factorizes the given number and returns both the divisor and the number divided by the divisor
+     * @param pq {BigInteger}
+     * @returns {{p: *, q: *}}
+     */
+    static factorize(pq) {
+        if (pq.remainder(2).equals(big_integer_1.default.zero)) {
+            return { p: (0, big_integer_1.default)(2), q: pq.divide((0, big_integer_1.default)(2)) };
+        }
+        let y = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        const c = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        const m = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        let g = big_integer_1.default.one;
+        let r = big_integer_1.default.one;
+        let q = big_integer_1.default.one;
+        let x = big_integer_1.default.zero;
+        let ys = big_integer_1.default.zero;
+        let k;
+        while (g.eq(big_integer_1.default.one)) {
+            x = y;
+            for (let i = 0; (0, big_integer_1.default)(i).lesser(r); i++) {
+                y = (0, Helpers_1.modExp)(y, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+            }
+            k = big_integer_1.default.zero;
+            while (k.lesser(r) && g.eq(big_integer_1.default.one)) {
+                ys = y;
+                const condition = big_integer_1.default.min(m, r.minus(k));
+                for (let i = 0; (0, big_integer_1.default)(i).lesser(condition); i++) {
+                    y = (0, Helpers_1.modExp)(y, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+                    q = q.multiply(x.minus(y).abs()).remainder(pq);
+                }
+                g = Factorizator.gcd(q, pq);
+                k = k.add(m);
+            }
+            r = r.multiply(2);
+        }
+        if (g.eq(pq)) {
+            while (true) {
+                ys = (0, Helpers_1.modExp)(ys, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+                g = Factorizator.gcd(x.minus(ys).abs(), pq);
+                if (g.greater(1)) {
+                    break;
+                }
+            }
+        }
+        const p = g;
+        q = pq.divide(g);
+        return p < q ? { p: p, q: q } : { p: q, q: p };
+    }
+}
+exports.Factorizator = Factorizator;

package/crypto/IGE.d.ts

@@ -0,0 +1,11 @@
+declare class IGE {
+    private key;
+    private iv;
+    constructor(key: Buffer, iv: Buffer);
+    private xorBuffers;
+    private aesEncryptBlock;
+    private aesDecryptBlock;
+    encryptIge(plainText: Buffer): Buffer;
+    decryptIge(cipherText: Buffer): Buffer;
+}
+export { IGE };

package/crypto/IGE.js

@@ -0,0 +1,115 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGE = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const Helpers = __importStar(require("../Helpers"));
+class IGE {
+    constructor(key, iv) {
+        if (key.length !== 32)
+            throw new Error("Key must be 32 bytes (AES-256)");
+        if (iv.length !== 32)
+            throw new Error("IV must be 32 bytes (2 * block size)");
+        this.key = key;
+        this.iv = iv;
+    }
+    xorBuffers(a, b) {
+        const res = Buffer.alloc(a.length);
+        for (let i = 0; i < a.length; i++) {
+            res[i] = a[i] ^ b[i];
+        }
+        return res;
+    }
+    aesEncryptBlock(block) {
+        const cipher = node_crypto_1.default.createCipheriv("aes-256-ecb", this.key, null);
+        cipher.setAutoPadding(false);
+        return Buffer.concat([cipher.update(block), cipher.final()]);
+    }
+    aesDecryptBlock(block) {
+        const decipher = node_crypto_1.default.createDecipheriv("aes-256-ecb", this.key, null);
+        decipher.setAutoPadding(false);
+        return Buffer.concat([decipher.update(block), decipher.final()]);
+    }
+    encryptIge(plainText) {
+        const blockSize = 16;
+        const padding = plainText.length % blockSize;
+        if (padding !== 0) {
+            plainText = Buffer.concat([
+                plainText,
+                Helpers.generateRandomBytes(blockSize - padding),
+            ]);
+        }
+        const iv1 = this.iv.subarray(0, blockSize);
+        const iv2 = this.iv.subarray(blockSize, 2 * blockSize);
+        let prevCipher = iv1;
+        let prevPlain = iv2;
+        const output = Buffer.alloc(plainText.length);
+        for (let i = 0; i < plainText.length; i += blockSize) {
+            const plainBlock = plainText.subarray(i, i + blockSize);
+            const xored = this.xorBuffers(plainBlock, prevCipher);
+            const encrypted = this.aesEncryptBlock(xored);
+            const cipherBlock = this.xorBuffers(encrypted, prevPlain);
+            cipherBlock.copy(output, i);
+            prevCipher = cipherBlock;
+            prevPlain = plainBlock;
+        }
+        return output;
+    }
+    decryptIge(cipherText) {
+        const blockSize = 16;
+        if (cipherText.length % blockSize !== 0) {
+            throw new Error("Cipher text must be multiple of 16 bytes");
+        }
+        const iv1 = this.iv.subarray(0, blockSize);
+        const iv2 = this.iv.subarray(blockSize, 2 * blockSize);
+        let prevCipher = iv1;
+        let prevPlain = iv2;
+        const output = Buffer.alloc(cipherText.length);
+        for (let i = 0; i < cipherText.length; i += blockSize) {
+            const cipherBlock = cipherText.subarray(i, i + blockSize);
+            const xored = this.xorBuffers(cipherBlock, prevPlain);
+            const decrypted = this.aesDecryptBlock(xored);
+            const plainBlock = this.xorBuffers(decrypted, prevCipher);
+            plainBlock.copy(output, i);
+            prevCipher = cipherBlock;
+            prevPlain = plainBlock;
+        }
+        return output;
+    }
+}
+exports.IGE = IGE;

package/crypto/RSA.d.ts

@@ -0,0 +1,14 @@
+import bigInt from "big-integer";
+export declare const _serverKeys: Map<string, {
+    n: bigInt.BigInteger;
+    e: number;
+}>;
+/**
+ * Encrypts the given data known the fingerprint to be used
+ * in the way Telegram requires us to do so (sha1(data) + data + padding)
+
+ * @param fingerprint the fingerprint of the RSA key.
+ * @param data the data to be encrypted.
+ * @returns {Buffer|*|undefined} the cipher text, or undefined if no key matching this fingerprint is found.
+ */
+export declare function encrypt(fingerprint: bigInt.BigInteger, data: Buffer): Promise<Buffer<ArrayBufferLike> | undefined>;

package/crypto/RSA.js

@@ -0,0 +1,70 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._serverKeys = void 0;
+exports.encrypt = encrypt;
+const big_integer_1 = __importDefault(require("big-integer"));
+const Helpers_1 = require("../Helpers");
+const PUBLIC_KEYS = [
+    {
+        fingerprint: (0, big_integer_1.default)("-3414540481677951611"),
+        n: (0, big_integer_1.default)("2937959817066933702298617714945612856538843112005886376816255642404751219133084745514657634448776440866" +
+            "1701890505066208632169112269581063774293102577308490531282748465986139880977280302242772832972539403531" +
+            "3160108704012876427630091361567343395380424193887227773571344877461690935390938502512438971889287359033" +
+            "8945177273024525306296338410881284207988753897636046529094613963869149149606209957083647645485599631919" +
+            "2747663615955633778034897140982517446405334423701359108810182097749467210509584293428076654573384828809" +
+            "574217079944388301239431309115013843331317877374435868468779972014486325557807783825502498215169806323"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("-5595554452916591101"),
+        n: (0, big_integer_1.default)("2534288944884041556497168959071347320689884775908477905258202659454602246385394058588521595116849196570822" +
+            "26493991806038180742006204637761354248846321625124031637930839216416315647409595294193595958529411668489405859523" +
+            "37613333022396096584117954892216031229237302943701877588456738335398602461675225081791820393153757504952636234951" +
+            "32323782003654358104782690612092797248736680529211579223142368426126233039432475078545094258975175539015664775146" +
+            "07193514399690599495696153028090507215003302390050778898553239175099482557220816446894421272976054225797071426466" +
+            "60768825302832201908302295573257427896031830742328565032949"),
+        e: 65537,
+    },
+];
+exports._serverKeys = new Map();
+PUBLIC_KEYS.forEach((_a) => {
+    var { fingerprint } = _a, keyInfo = __rest(_a, ["fingerprint"]);
+    exports._serverKeys.set(fingerprint.toString(), keyInfo);
+});
+/**
+ * Encrypts the given data known the fingerprint to be used
+ * in the way Telegram requires us to do so (sha1(data) + data + padding)
+
+ * @param fingerprint the fingerprint of the RSA key.
+ * @param data the data to be encrypted.
+ * @returns {Buffer|*|undefined} the cipher text, or undefined if no key matching this fingerprint is found.
+ */
+async function encrypt(fingerprint, data) {
+    const key = exports._serverKeys.get(fingerprint.toString());
+    if (!key) {
+        return undefined;
+    }
+    // len(sha1.digest) is always 20, so we're left with 255 - 20 - x padding
+    const rand = (0, Helpers_1.generateRandomBytes)(235 - data.length);
+    const toEncrypt = Buffer.concat([await (0, Helpers_1.sha1)(data), data, rand]);
+    // rsa module rsa.encrypt adds 11 bits for padding which we don't want
+    // rsa module uses rsa.transform.bytes2int(to_encrypt), easier way:
+    const payload = (0, Helpers_1.readBigIntFromBuffer)(toEncrypt, false);
+    const encrypted = (0, Helpers_1.modExp)(payload, (0, big_integer_1.default)(key.e), key.n);
+    // rsa module uses transform.int2bytes(encrypted, keylength), easier:
+    return (0, Helpers_1.readBufferFromBigInt)(encrypted, 256, false);
+}

package/crypto/converters.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Uint32Array -> ArrayBuffer (low-endian os)
+ */
+export declare function i2abLow(buf: Uint32Array): ArrayBuffer;
+/**
+ * Uint32Array -> ArrayBuffer (big-endian os)
+ */
+export declare function i2abBig(buf: Uint32Array): ArrayBuffer;
+/**
+ * ArrayBuffer -> Uint32Array (low-endian os)
+ */
+export declare function ab2iLow(ab: ArrayBuffer | SharedArrayBuffer | Uint8Array): Uint32Array;
+/**
+ * ArrayBuffer -> Uint32Array (big-endian os)
+ */
+export declare function ab2iBig(ab: ArrayBuffer | SharedArrayBuffer | Uint8Array): Uint32Array;
+export declare const isBigEndian: boolean;
+export declare const i2ab: typeof i2abBig;
+export declare const ab2i: typeof ab2iBig;

package/crypto/converters.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ab2i = exports.i2ab = exports.isBigEndian = void 0;
+exports.i2abLow = i2abLow;
+exports.i2abBig = i2abBig;
+exports.ab2iLow = ab2iLow;
+exports.ab2iBig = ab2iBig;
+/**
+ * Uint32Array -> ArrayBuffer (low-endian os)
+ */
+function i2abLow(buf) {
+    const uint8 = new Uint8Array(buf.length * 4);
+    let i = 0;
+    for (let j = 0; j < buf.length; j++) {
+        const int = buf[j];
+        uint8[i++] = int >>> 24;
+        uint8[i++] = (int >> 16) & 0xff;
+        uint8[i++] = (int >> 8) & 0xff;
+        uint8[i++] = int & 0xff;
+    }
+    return uint8.buffer;
+}
+/**
+ * Uint32Array -> ArrayBuffer (big-endian os)
+ */
+function i2abBig(buf) {
+    return buf.buffer;
+}
+/**
+ * ArrayBuffer -> Uint32Array (low-endian os)
+ */
+function ab2iLow(ab) {
+    const uint8 = new Uint8Array(ab);
+    const buf = new Uint32Array(uint8.length / 4);
+    for (let i = 0; i < uint8.length; i += 4) {
+        buf[i / 4] =
+            (uint8[i] << 24) ^
+                (uint8[i + 1] << 16) ^
+                (uint8[i + 2] << 8) ^
+                uint8[i + 3];
+    }
+    return buf;
+}
+/**
+ * ArrayBuffer -> Uint32Array (big-endian os)
+ */
+function ab2iBig(ab) {
+    return new Uint32Array(ab);
+}
+exports.isBigEndian = new Uint8Array(new Uint32Array([0x01020304]))[0] === 0x01;
+exports.i2ab = exports.isBigEndian ? i2abBig : i2abLow;
+exports.ab2i = exports.isBigEndian ? ab2iBig : ab2iLow;

package/crypto/crypto.d.ts

@@ -0,0 +1,19 @@
+export declare class CTR {
+    private cipher;
+    private decipher;
+    constructor(key: Buffer, iv: Buffer, algorithm: string);
+    update(plainText: Buffer): any;
+    encrypt(plainText: Buffer): any;
+    decrypt(cipherText: Buffer): any;
+}
+export declare function createDecipher(algorithm: string, key: Buffer, iv: Buffer): CTR;
+export declare function createCipher(algorithm: string, key: Buffer, iv: Buffer): CTR;
+export declare function randomBytes(count: number): Buffer<ArrayBufferLike>;
+export declare class Hash {
+    private readonly hash;
+    constructor(algorithm: string);
+    update(data: Buffer): void;
+    digest(): any;
+}
+export declare function pbkdf2Sync(password: any, salt: any, iterations: any, keylen: any, digest: any): Buffer<ArrayBufferLike>;
+export declare function createHash(algorithm: string): Hash;

package/crypto/crypto.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = exports.CTR = void 0;
+exports.createDecipher = createDecipher;
+exports.createCipher = createCipher;
+exports.randomBytes = randomBytes;
+exports.pbkdf2Sync = pbkdf2Sync;
+exports.createHash = createHash;
+const node_crypto_1 = require("node:crypto");
+class CTR {
+    constructor(key, iv, algorithm) {
+        this.cipher = (0, node_crypto_1.createCipheriv)(algorithm, key, iv);
+        this.decipher = (0, node_crypto_1.createDecipheriv)(algorithm, key, iv);
+    }
+    update(plainText) {
+        return this.encrypt(plainText);
+    }
+    encrypt(plainText) {
+        return this.cipher.update(plainText);
+    }
+    decrypt(cipherText) {
+        return this.decipher.update(cipherText);
+    }
+}
+exports.CTR = CTR;
+function createDecipher(algorithm, key, iv) {
+    if (algorithm.includes("ECB")) {
+        throw new Error("ECB mode is not supported");
+    }
+    return new CTR(key, iv, algorithm);
+}
+function createCipher(algorithm, key, iv) {
+    if (algorithm.includes("ECB")) {
+        throw new Error("ECB mode is not supported");
+    }
+    return new CTR(key, iv, algorithm);
+}
+function randomBytes(count) {
+    return (0, node_crypto_1.randomBytes)(count);
+}
+class Hash {
+    constructor(algorithm) {
+        this.hash = (0, node_crypto_1.createHash)(algorithm);
+    }
+    update(data) {
+        this.hash.update(data);
+    }
+    digest() {
+        return this.hash.digest();
+    }
+}
+exports.Hash = Hash;
+function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+    return (0, node_crypto_1.pbkdf2Sync)(password, salt, iterations, keylen, digest);
+}
+function createHash(algorithm) {
+    return new Hash(algorithm);
+}

package/crypto/words.d.ts

@@ -0,0 +1,6 @@
+export declare function s2i(str: string, pos: number): number;
+/**
+ * Helper function for transforming string key to Uint32Array
+ */
+export declare function getWords(key: string | Uint8Array | Uint32Array): Uint32Array<ArrayBufferLike>;
+export declare function xor(left: Uint32Array, right: Uint32Array, to?: Uint32Array<ArrayBufferLike>): void;

package/crypto/words.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Imported from https://github.com/spalt08/cryptography/blob/master/packages/aes/src/utils/words.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s2i = s2i;
+exports.getWords = getWords;
+exports.xor = xor;
+function s2i(str, pos) {
+    return ((str.charCodeAt(pos) << 24) ^
+        (str.charCodeAt(pos + 1) << 16) ^
+        (str.charCodeAt(pos + 2) << 8) ^
+        str.charCodeAt(pos + 3));
+}
+/**
+ * Helper function for transforming string key to Uint32Array
+ */
+function getWords(key) {
+    if (key instanceof Uint32Array) {
+        return key;
+    }
+    if (typeof key === "string") {
+        if (key.length % 4 !== 0)
+            for (let i = key.length % 4; i <= 4; i++)
+                key += "\0x00";
+        const buf = new Uint32Array(key.length / 4);
+        for (let i = 0; i < key.length; i += 4)
+            buf[i / 4] = s2i(key, i);
+        return buf;
+    }
+    if (key instanceof Uint8Array) {
+        const buf = new Uint32Array(key.length / 4);
+        for (let i = 0; i < key.length; i += 4) {
+            buf[i / 4] =
+                (key[i] << 24) ^
+                    (key[i + 1] << 16) ^
+                    (key[i + 2] << 8) ^
+                    key[i + 3];
+        }
+        return buf;
+    }
+    throw new Error("Unable to create 32-bit words");
+}
+function xor(left, right, to = left) {
+    for (let i = 0; i < left.length; i++)
+        to[i] = left[i] ^ right[i];
+}

package/define.d.ts

@@ -0,0 +1,77 @@
+import type { Button } from "./tl/custom/button";
+import { Api } from "./tl";
+import type { CustomFile } from "./client/uploads";
+import TypeUser = Api.TypeUser;
+import TypeChat = Api.TypeChat;
+import TypeInputUser = Api.TypeInputUser;
+import TypeInputChannel = Api.TypeInputChannel;
+import bigInt from "big-integer";
+import { WriteStream } from "fs";
+
+type ValueOf<T> = T[keyof T];
+type Phone = string;
+type Username = string;
+type PeerID = number;
+type Entity = Api.User | Api.Chat | Api.Channel | TypeUser | TypeChat;
+type FullEntity =
+    | Api.UserFull
+    | Api.messages.ChatFull
+    | Api.ChatFull
+    | Api.ChannelFull;
+type PeerLike = Api.TypePeer | Api.TypeInputPeer | Entity | FullEntity;
+type EntityLike =
+    | bigInt.BigInteger
+    | Phone
+    | Username
+    | PeerID
+    | Api.TypePeer
+    | Api.TypeInputPeer
+    | Entity
+    | FullEntity
+    | TypeUser
+    | TypeChat
+    | TypeInputChannel
+    | TypeInputUser;
+
+type EntitiesLike = EntityLike[];
+type MessageIDLike =
+    | number
+    | Api.Message
+    | Api.MessageService
+    | Api.TypeInputMessage;
+type MessageLike = string | Api.Message;
+
+type LocalPath = string;
+type ExternalUrl = string;
+type BotFileID = string;
+
+type FileLike =
+    | LocalPath
+    | ExternalUrl
+    | BotFileID
+    | Buffer
+    | Api.TypeMessageMedia
+    | Api.TypeInputMedia
+    | Api.TypeInputFile
+    | Api.TypeInputFileLocation
+    | File
+    | Api.TypePhoto
+    | Api.TypeDocument
+    | CustomFile;
+type OutFile =
+    | string
+    | Buffer
+    | WriteStream
+    | { write: Function; close?: Function };
+type ProgressCallback = (
+    downloaded: bigInt.BigInteger,
+    total: bigInt.BigInteger
+) => void;
+type ButtonLike = Api.TypeKeyboardButton | Button;
+
+type MarkupLike =
+    | Api.TypeReplyMarkup
+    | ButtonLike
+    | ButtonLike[]
+    | ButtonLike[][];
+type DateLike = number;

package/entityCache.d.ts

@@ -0,0 +1,7 @@
+import bigInt from "big-integer";
+export declare class EntityCache {
+    private cacheMap;
+    constructor();
+    add(entities: any): void;
+    get(item: bigInt.BigInteger | string | undefined): any;
+}

package/entityCache.js

@@ -0,0 +1,79 @@
+"use strict";
+// Which updates have the following fields?
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityCache = void 0;
+const Utils_1 = require("./Utils");
+const Helpers_1 = require("./Helpers");
+const tl_1 = require("./tl");
+const big_integer_1 = __importDefault(require("big-integer"));
+class EntityCache {
+    constructor() {
+        this.cacheMap = new Map();
+    }
+    add(entities) {
+        const temp = [];
+        if (!(0, Helpers_1.isArrayLike)(entities)) {
+            if (entities != undefined) {
+                if (typeof entities == "object") {
+                    if ("chats" in entities) {
+                        temp.push(...entities.chats);
+                    }
+                    if ("users" in entities) {
+                        temp.push(...entities.users);
+                    }
+                    if ("user" in entities) {
+                        temp.push(entities.user);
+                    }
+                }
+            }
+            if (temp.length) {
+                entities = temp;
+            }
+            else {
+                return;
+            }
+        }
+        for (const entity of entities) {
+            try {
+                const pid = (0, Utils_1.getPeerId)(entity);
+                if (!this.cacheMap.has(pid.toString())) {
+                    this.cacheMap.set(pid.toString(), (0, Utils_1.getInputPeer)(entity));
+                }
+            }
+            catch (e) { }
+        }
+    }
+    get(item) {
+        if (item == undefined) {
+            throw new Error("No cached entity for the given key");
+        }
+        item = (0, Helpers_1.returnBigInt)(item);
+        if (item.lesser(big_integer_1.default.zero)) {
+            let res;
+            try {
+                res = this.cacheMap.get((0, Utils_1.getPeerId)(item).toString());
+                if (res) {
+                    return res;
+                }
+            }
+            catch (e) {
+                throw new Error("Invalid key will not have entity");
+            }
+        }
+        for (const cls of [tl_1.Api.PeerUser, tl_1.Api.PeerChat, tl_1.Api.PeerChannel]) {
+            const result = this.cacheMap.get((0, Utils_1.getPeerId)(new cls({
+                userId: item,
+                chatId: item,
+                channelId: item,
+            })).toString());
+            if (result) {
+                return result;
+            }
+        }
+        throw new Error("No cached entity for the given key");
+    }
+}
+exports.EntityCache = EntityCache;