teleproto 1.214.0

package/extensions/BinaryReader.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryReader = void 0;
+const errors_1 = require("../errors");
+const core_1 = require("../tl/core");
+const AllTLObjects_1 = require("../tl/AllTLObjects");
+const Helpers_1 = require("../Helpers");
+class BinaryReader {
+    /**
+     * Small utility class to read binary data.
+     * @param data {Buffer}
+     */
+    constructor(data) {
+        this.stream = data;
+        this._last = undefined;
+        this.offset = 0;
+    }
+    // region Reading
+    // "All numbers are written as little endian."
+    // https://core.telegram.org/mtproto
+    /**
+     * Reads a single byte value.
+     */
+    readByte() {
+        return this.read(1)[0];
+    }
+    /**
+     * Reads an integer (4 bytes or 32 bits) value.
+     * @param signed {Boolean}
+     */
+    readInt(signed = true) {
+        let res;
+        if (signed) {
+            res = this.stream.readInt32LE(this.offset);
+        }
+        else {
+            res = this.stream.readUInt32LE(this.offset);
+        }
+        this.offset += 4;
+        return res;
+    }
+    /**
+     * Reads a long integer (8 bytes or 64 bits) value.
+     * @param signed
+     * @returns {BigInteger}
+     */
+    readLong(signed = true) {
+        return this.readLargeInt(64, signed);
+    }
+    /**
+     * Reads a real floating point (4 bytes) value.
+     * @returns {number}
+     */
+    readFloat() {
+        return this.read(4).readFloatLE(0);
+    }
+    /**
+     * Reads a real floating point (8 bytes) value.
+     * @returns {BigInteger}
+     */
+    readDouble() {
+        // was this a bug ? it should have been <d
+        return this.read(8).readDoubleLE(0);
+    }
+    /**
+     * Reads a n-bits long integer value.
+     * @param bits
+     * @param signed {Boolean}
+     */
+    readLargeInt(bits, signed = true) {
+        const buffer = this.read(Math.floor(bits / 8));
+        return (0, Helpers_1.readBigIntFromBuffer)(buffer, true, signed);
+    }
+    /**
+     * Read the given amount of bytes, or -1 to read all remaining.
+     * @param length {number}
+     * @param checkLength {boolean} whether to check if the length overflows or not.
+     */
+    read(length = -1, checkLength = true) {
+        if (length === -1) {
+            length = this.stream.length - this.offset;
+        }
+        const result = this.stream.slice(this.offset, this.offset + length);
+        this.offset += length;
+        if (checkLength && result.length !== length) {
+            throw Error(`No more data left to read (need ${length}, got ${result.length}: ${result}); last read ${this._last}`);
+        }
+        this._last = result;
+        return result;
+    }
+    /**
+     * Gets the byte array representing the current buffer as a whole.
+     * @returns {Buffer}
+     */
+    getBuffer() {
+        return this.stream;
+    }
+    // endregion
+    // region Telegram custom reading
+    /**
+     * Reads a Telegram-encoded byte array, without the need of
+     * specifying its length.
+     * @returns {Buffer}
+     */
+    tgReadBytes() {
+        const firstByte = this.readByte();
+        let padding;
+        let length;
+        if (firstByte === 254) {
+            length =
+                this.readByte() |
+                    (this.readByte() << 8) |
+                    (this.readByte() << 16);
+            padding = length % 4;
+        }
+        else {
+            length = firstByte;
+            padding = (length + 1) % 4;
+        }
+        const data = this.read(length);
+        if (padding > 0) {
+            padding = 4 - padding;
+            this.read(padding);
+        }
+        return data;
+    }
+    /**
+     * Reads a Telegram-encoded string.
+     * @returns {string}
+     */
+    tgReadString() {
+        return this.tgReadBytes().toString("utf-8");
+    }
+    /**
+     * Reads a Telegram boolean value.
+     * @returns {boolean}
+     */
+    tgReadBool() {
+        const value = this.readInt(false);
+        if (value === 0x997275b5) {
+            // boolTrue
+            return true;
+        }
+        else if (value === 0xbc799737) {
+            // boolFalse
+            return false;
+        }
+        else {
+            throw new Error(`Invalid boolean code ${value.toString(16)}`);
+        }
+    }
+    /**
+     * Reads and converts Unix time (used by Telegram)
+     * into a Javascript {Date} object.
+     * @returns {Date}
+     */
+    tgReadDate() {
+        const value = this.readInt();
+        return new Date(value * 1000);
+    }
+    /**
+     * Reads a Telegram object.
+     */
+    tgReadObject() {
+        const constructorId = this.readInt(false);
+        let clazz = AllTLObjects_1.tlobjects[constructorId];
+        if (clazz === undefined) {
+            /**
+             * The class was undefined, but there's still a
+             * chance of it being a manually parsed value like bool!
+             */
+            const value = constructorId;
+            if (value === 0x997275b5) {
+                // boolTrue
+                return true;
+            }
+            else if (value === 0xbc799737) {
+                // boolFalse
+                return false;
+            }
+            else if (value === 0x1cb5c415) {
+                // Vector
+                const temp = [];
+                const length = this.readInt();
+                for (let i = 0; i < length; i++) {
+                    temp.push(this.tgReadObject());
+                }
+                return temp;
+            }
+            clazz = core_1.coreObjects.get(constructorId);
+            if (clazz === undefined) {
+                // If there was still no luck, give up
+                this.seek(-4); // Go back
+                const pos = this.tellPosition();
+                const error = new errors_1.TypeNotFoundError(constructorId, this.read());
+                this.setPosition(pos);
+                throw error;
+            }
+        }
+        return clazz.fromReader(this);
+    }
+    /**
+     * Reads a vector (a list) of Telegram objects.
+     * @returns {[Buffer]}
+     */
+    tgReadVector() {
+        if (this.readInt(false) !== 0x1cb5c415) {
+            throw new Error("Invalid constructor code, vector was expected");
+        }
+        const count = this.readInt();
+        const temp = [];
+        for (let i = 0; i < count; i++) {
+            temp.push(this.tgReadObject());
+        }
+        return temp;
+    }
+    // endregion
+    // region Position related
+    /**
+     * Tells the current position on the stream.
+     * @returns {number}
+     */
+    tellPosition() {
+        return this.offset;
+    }
+    /**
+     * Sets the current position on the stream.
+     * @param position
+     */
+    setPosition(position) {
+        this.offset = position;
+    }
+    /**
+     * Seeks the stream position given an offset from the current position.
+     * The offset may be negative.
+     * @param offset
+     */
+    seek(offset) {
+        this.offset += offset;
+    }
+}
+exports.BinaryReader = BinaryReader;

package/extensions/BinaryWriter.d.ts

@@ -0,0 +1,6 @@
+export declare class BinaryWriter {
+    private readonly _buffers;
+    constructor(stream: Buffer);
+    write(buffer: Buffer): void;
+    getValue(): Buffer;
+}

package/extensions/BinaryWriter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryWriter = void 0;
+class BinaryWriter {
+    constructor(stream) {
+        this._buffers = [stream];
+    }
+    write(buffer) {
+        this._buffers.push(buffer);
+    }
+    getValue() {
+        return Buffer.concat(this._buffers);
+    }
+}
+exports.BinaryWriter = BinaryWriter;

package/extensions/Deferred.d.ts

@@ -0,0 +1,8 @@
+export default class Deferred<T = void> {
+    promise: Promise<T>;
+    reject: (reason?: any) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+    constructor();
+    static resolved(): Deferred<void>;
+    static resolved<T>(value: T): Deferred<T>;
+}

package/extensions/Deferred.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
+    static resolved(value) {
+        const deferred = new Deferred();
+        deferred.resolve(value);
+        return deferred;
+    }
+}
+exports.default = Deferred;

package/extensions/Logger.d.ts

@@ -0,0 +1,54 @@
+export declare enum LogLevel {
+    NONE = "none",
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug"
+}
+export declare class Logger {
+    private levels;
+    private nodeColors;
+    messageFormat: string;
+    private _logLevel;
+    tzOffset: number;
+    constructor(level?: LogLevel);
+    /**
+     *
+     * @param level {string}
+     * @returns {boolean}
+     */
+    canSend(level: LogLevel): boolean;
+    /**
+     * @param message {string}
+     */
+    warn(message: string): void;
+    /**
+     * @param message {string}
+     */
+    info(message: string): void;
+    /**
+     * @param message {string}
+     */
+    debug(message: string): void;
+    /**
+     * @param message {string}
+     */
+    error(message: string): void;
+    format(message: string, level: string): string;
+    get logLevel(): LogLevel;
+    setLevel(level: LogLevel): void;
+    static setLevel(level: string): void;
+    /**
+     * @param level {string}
+     * @param message {string}
+     */
+    _log(level: LogLevel, message: string): void;
+    /**
+     * Override this function for custom Logger. <br />
+     *
+     * @param level {string}
+     * @param message {string}
+     */
+    log(level: LogLevel, message: string): void;
+    getDateTime(): string;
+}

package/extensions/Logger.js

@@ -0,0 +1,128 @@
+"use strict";
+// let _level: string | undefined = undefined;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["NONE"] = "none";
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const NodeColors = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    underline: "\x1b[4m",
+};
+class Logger {
+    constructor(level) {
+        this.levels = ["error", "warn", "info", "debug"];
+        this._logLevel = level || LogLevel.INFO;
+        this.nodeColors = {
+            warn: NodeColors.magenta,
+            info: NodeColors.yellow,
+            debug: NodeColors.cyan,
+            error: NodeColors.red,
+            reset: NodeColors.reset
+        };
+        this.messageFormat = "[%t] [%l] - [%m]";
+        this.tzOffset = new Date().getTimezoneOffset() * 60000;
+    }
+    /**
+     *
+     * @param level {string}
+     * @returns {boolean}
+     */
+    canSend(level) {
+        return this._logLevel
+            ? this.levels.indexOf(this._logLevel) >= this.levels.indexOf(level)
+            : false;
+    }
+    /**
+     * @param message {string}
+     */
+    warn(message) {
+        this._log(LogLevel.WARN, message);
+    }
+    /**
+     * @param message {string}
+     */
+    info(message) {
+        this._log(LogLevel.INFO, message);
+    }
+    /**
+     * @param message {string}
+     */
+    debug(message) {
+        this._log(LogLevel.DEBUG, message);
+    }
+    /**
+     * @param message {string}
+     */
+    error(message) {
+        this._log(LogLevel.ERROR, message);
+    }
+    format(message, level) {
+        return this.messageFormat
+            .replace("%t", this.getDateTime())
+            .replace("%l", level.toUpperCase())
+            .replace("%m", message);
+    }
+    get logLevel() {
+        return this._logLevel;
+    }
+    setLevel(level) {
+        this._logLevel = level;
+    }
+    static setLevel(level) {
+        console.log("Logger.setLevel is deprecated, it will has no effect. Please, use client.setLogLevel instead.");
+    }
+    /**
+     * @param level {string}
+     * @param message {string}
+     */
+    _log(level, message) {
+        if (this.canSend(level)) {
+            this.log(level, message);
+        }
+    }
+    /**
+     * Override this function for custom Logger. <br />
+     *
+     * @param level {string}
+     * @param message {string}
+     */
+    log(level, message) {
+        let nodeColor;
+        switch (level) {
+            case LogLevel.ERROR:
+                nodeColor = this.nodeColors.error;
+                break;
+            case LogLevel.WARN:
+                nodeColor = this.nodeColors.warn;
+                break;
+            case LogLevel.INFO:
+                nodeColor = this.nodeColors.info;
+                break;
+            case LogLevel.DEBUG:
+                nodeColor = this.nodeColors.debug;
+                break;
+            default:
+                nodeColor = "";
+        }
+        console.log(nodeColor + this.format(message, level) + this.nodeColors.reset);
+    }
+    getDateTime() {
+        return new Date(Date.now() - this.tzOffset).toISOString().slice(0, -1);
+    }
+}
+exports.Logger = Logger;

package/extensions/MessagePacker.d.ts

@@ -0,0 +1,21 @@
+import type { MTProtoState } from "../network/MTProtoState";
+import type { RequestState } from "../network/RequestState";
+export declare class MessagePacker {
+    private _state;
+    _pendingStates: RequestState[];
+    private _queue;
+    private _ready;
+    private setReady;
+    private _log;
+    constructor(state: MTProtoState, logger: any);
+    values(): any[];
+    append(state?: RequestState, setReady?: boolean, atStart?: boolean): void;
+    prepend(states: RequestState[]): void;
+    extend(states: RequestState[]): void;
+    clear(): void;
+    wait(): Promise<void>;
+    get(): Promise<{
+        batch: any[];
+        data: Buffer<ArrayBufferLike>;
+    } | null | undefined>;
+}

package/extensions/MessagePacker.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePacker = void 0;
+const core_1 = require("../tl/core");
+const core_2 = require("../tl/core");
+const BinaryWriter_1 = require("./BinaryWriter");
+const USE_INVOKE_AFTER_WITH = new Set([
+    "messages.SendMessage",
+    "messages.SendMedia",
+    "messages.SendMultiMedia",
+    "messages.ForwardMessages",
+    "messages.SendInlineBotResult",
+]);
+class MessagePacker {
+    constructor(state, logger) {
+        this._state = state;
+        this._queue = [];
+        this._pendingStates = [];
+        this._ready = new Promise((resolve) => {
+            this.setReady = resolve;
+        });
+        this._log = logger;
+    }
+    values() {
+        return this._queue;
+    }
+    append(state, setReady = true, atStart = false) {
+        var _a, _b;
+        // We need to check if there is already a `USE_INVOKE_AFTER_WITH` request
+        if (state && USE_INVOKE_AFTER_WITH.has(state.request.className)) {
+            if (atStart) {
+                // Assign `after` for the previously first `USE_INVOKE_AFTER_WITH` request
+                for (let i = 0; i < this._queue.length; i++) {
+                    if (USE_INVOKE_AFTER_WITH.has((_a = this._queue[i]) === null || _a === void 0 ? void 0 : _a.request.className)) {
+                        this._queue[i].after = state;
+                        break;
+                    }
+                }
+            }
+            else {
+                // Assign after for the previous `USE_INVOKE_AFTER_WITH` request
+                for (let i = this._queue.length - 1; i >= 0; i--) {
+                    if (USE_INVOKE_AFTER_WITH.has((_b = this._queue[i]) === null || _b === void 0 ? void 0 : _b.request.className)) {
+                        state.after = this._queue[i];
+                        break;
+                    }
+                }
+            }
+        }
+        if (atStart) {
+            this._queue.unshift(state);
+        }
+        else {
+            this._queue.push(state);
+        }
+        if (setReady && this.setReady) {
+            this.setReady(true);
+        }
+        // 1658238041=MsgsAck, we don't care about MsgsAck here because they never resolve anyway.
+        if (state && state.request.CONSTRUCTOR_ID !== 1658238041) {
+            this._pendingStates.push(state);
+            state
+                .promise // Using finally causes triggering `unhandledrejection` event
+                .catch((err) => { })
+                .finally(() => {
+                this._pendingStates = this._pendingStates.filter((s) => s !== state);
+            });
+        }
+    }
+    prepend(states) {
+        states.reverse().forEach((state) => {
+            this.append(state, false, true);
+        });
+        if (this.setReady) {
+            this.setReady(true);
+        }
+    }
+    extend(states) {
+        states.forEach((state) => {
+            this.append(state, false);
+        });
+        if (this.setReady) {
+            this.setReady(true);
+        }
+    }
+    clear() {
+        this._queue = [];
+        this.append(undefined);
+    }
+    async wait() {
+        if (!this._queue.length) {
+            this._ready = new Promise((resolve) => {
+                this.setReady = resolve;
+            });
+            await this._ready;
+        }
+    }
+    async get() {
+        if (!this._queue[this._queue.length - 1]) {
+            this._queue = this._queue.filter(Boolean);
+            return undefined;
+        }
+        let data;
+        let buffer = new BinaryWriter_1.BinaryWriter(Buffer.alloc(0));
+        const batch = [];
+        let size = 0;
+        while (this._queue.length &&
+            batch.length <= core_1.MessageContainer.MAXIMUM_LENGTH) {
+            const state = this._queue.shift();
+            if (!state) {
+                continue;
+            }
+            size += state.data.length + core_2.TLMessage.SIZE_OVERHEAD;
+            if (size <= core_1.MessageContainer.MAXIMUM_SIZE) {
+                let afterId;
+                if (state.after) {
+                    afterId = state.after.msgId;
+                }
+                if (state.after) {
+                    afterId = state.after.msgId;
+                }
+                state.msgId = await this._state.writeDataAsMessage(buffer, state.data, state.request.classType === "request", afterId);
+                this._log.debug(`Assigned msgId = ${state.msgId} to ${state.request.className ||
+                    state.request.constructor.name}`);
+                batch.push(state);
+                continue;
+            }
+            if (batch.length) {
+                this._queue.unshift(state);
+                break;
+            }
+            this._log.warn(`Message payload for ${state.request.className || state.request.constructor.name} is too long ${state.data.length} and cannot be sent`);
+            state.promise.reject("Request Payload is too big");
+            size = 0;
+        }
+        if (!batch.length) {
+            return null;
+        }
+        if (batch.length > 1) {
+            const b = Buffer.alloc(8);
+            b.writeUInt32LE(core_1.MessageContainer.CONSTRUCTOR_ID, 0);
+            b.writeInt32LE(batch.length, 4);
+            data = Buffer.concat([b, buffer.getValue()]);
+            buffer = new BinaryWriter_1.BinaryWriter(Buffer.alloc(0));
+            const containerId = await this._state.writeDataAsMessage(buffer, data, false);
+            for (const s of batch) {
+                s.containerId = containerId;
+            }
+        }
+        data = buffer.getValue();
+        return { batch, data };
+    }
+}
+exports.MessagePacker = MessagePacker;

package/extensions/PendingState.d.ts

@@ -0,0 +1,12 @@
+import { RequestState } from "../network/RequestState";
+import bigInt from "big-integer";
+export declare class PendingState {
+    _pending: Map<string, RequestState>;
+    constructor();
+    set(msgId: bigInt.BigInteger, state: RequestState): void;
+    get(msgId: bigInt.BigInteger): RequestState | undefined;
+    getAndDelete(msgId: bigInt.BigInteger): RequestState | undefined;
+    values(): RequestState[];
+    delete(msgId: bigInt.BigInteger): void;
+    clear(): void;
+}

package/extensions/PendingState.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendingState = void 0;
+class PendingState {
+    constructor() {
+        this._pending = new Map();
+    }
+    set(msgId, state) {
+        this._pending.set(msgId.toString(), state);
+    }
+    get(msgId) {
+        return this._pending.get(msgId.toString());
+    }
+    getAndDelete(msgId) {
+        const state = this.get(msgId);
+        this.delete(msgId);
+        return state;
+    }
+    values() {
+        return Array.from(this._pending.values());
+    }
+    delete(msgId) {
+        this._pending.delete(msgId.toString());
+    }
+    clear() {
+        this._pending.clear();
+    }
+}
+exports.PendingState = PendingState;