teleproto 1.214.0

package/extensions/markdown.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownParser = void 0;
+const messageParse_1 = require("../client/messageParse");
+class MarkdownParser {
+    // TODO maybe there is a better way :shrug:
+    static parse(message) {
+        let i = 0;
+        const keys = {};
+        for (const k in messageParse_1.DEFAULT_DELIMITERS) {
+            keys[k] = false;
+        }
+        const entities = [];
+        const tempEntities = {};
+        while (i < message.length) {
+            let foundIndex = -1;
+            let foundDelim = undefined;
+            for (const key of Object.keys(messageParse_1.DEFAULT_DELIMITERS)) {
+                const index = message.indexOf(key, i);
+                if (index > -1 && (foundIndex === -1 || index < foundIndex)) {
+                    foundIndex = index;
+                    foundDelim = key;
+                }
+            }
+            if (foundIndex === -1 || foundDelim == undefined) {
+                break;
+            }
+            if (!keys[foundDelim]) {
+                tempEntities[foundDelim] = new messageParse_1.DEFAULT_DELIMITERS[foundDelim]({
+                    offset: foundIndex,
+                    length: -1,
+                    language: "",
+                });
+                keys[foundDelim] = true;
+            }
+            else {
+                keys[foundDelim] = false;
+                tempEntities[foundDelim].length =
+                    foundIndex - tempEntities[foundDelim].offset;
+                entities.push(tempEntities[foundDelim]);
+            }
+            message = message.toString().replace(foundDelim, "");
+            i = foundIndex;
+        }
+        return [message, entities];
+    }
+    static unparse(text, entities) {
+        const delimiters = messageParse_1.DEFAULT_DELIMITERS;
+        if (!text || !entities) {
+            return text;
+        }
+        let insertAt = [];
+        const tempDelimiters = new Map();
+        Object.keys(delimiters).forEach((key) => {
+            tempDelimiters.set(delimiters[key].className, key);
+        });
+        for (const entity of entities) {
+            const s = entity.offset;
+            const e = entity.offset + entity.length;
+            const delimiter = tempDelimiters.get(entity.className);
+            if (delimiter) {
+                insertAt.push([s, delimiter]);
+                insertAt.push([e, delimiter]);
+            }
+        }
+        insertAt = insertAt.sort((a, b) => {
+            return a[0] - b[0];
+        });
+        while (insertAt.length) {
+            const [at, what] = insertAt.pop();
+            text = text.slice(0, at) + what + text.slice(at);
+        }
+        return text;
+    }
+}
+exports.MarkdownParser = MarkdownParser;

package/extensions/markdownv2.d.ts

@@ -0,0 +1,5 @@
+import { Api } from "../tl";
+export declare class MarkdownV2Parser {
+    static parse(message: string): [string, Api.TypeMessageEntity[]];
+    static unparse(text: string, entities: Api.TypeMessageEntity[] | undefined): string;
+}

package/extensions/markdownv2.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownV2Parser = void 0;
+const html_1 = require("./html");
+class MarkdownV2Parser {
+    static parse(message) {
+        // Bold
+        message = message.replace(/\*(.*?)\*/g, "<b>$1</b>");
+        // underline
+        message = message.replace(/__(.*?)__/g, "<u>$1</u>");
+        // strikethrough
+        message = message.replace(/~(.*?)~/g, "<s>$1</s>");
+        // italic
+        message = message.replace(/-(.*?)-/g, "<i>$1</i>");
+        // pre
+        message = message.replace(/```([\s\S]*?)```/g, "<pre>$1</pre>");
+        // code
+        message = message.replace(/`(.*?)`/g, "<code>$1</code>");
+        // Spoiler
+        message = message.replace(/\|\|(.*?)\|\|/g, "<spoiler>$1</spoiler>");
+        // Inline URL
+        message = message.replace(/(?<!\!)\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+        // Emoji
+        message = message.replace(/!\[([^\]]+)\]\(tg:\/\/emoji\?id=(\d+)\)/g, '<tg-emoji emoji-id="$2">$1</tg-emoji>');
+        //
+        return html_1.HTMLParser.parse(message);
+    }
+    static unparse(text, entities) {
+        text = html_1.HTMLParser.unparse(text, entities);
+        // Bold
+        text = text.replace(/<b>(.*?)<\/b>/g, "*$1*");
+        // Underline
+        text = text.replace(/<u>(.*?)<\/u>/g, "__$1__");
+        // Code
+        text = text.replace(/<code>(.*?)<\/code>/g, "`$1`");
+        // Pre
+        text = text.replace(/<pre>(.*?)<\/pre>/g, "```$1```");
+        // strikethrough
+        text = text.replace(/<s>(.*?)<\/s>/g, "~$1~");
+        // Italic
+        text = text.replace(/<i>(.*?)<\/i>/g, "-$1-");
+        // Spoiler
+        text = text.replace(/<spoiler>(.*?)<\/spoiler>/g, "||$1||");
+        // Inline URL
+        text = text.replace(/<a href="([^"]+)">([^<]+)<\/a>/g, "[$2]($1)");
+        // Emoji
+        text = text.replace(/<tg-emoji emoji-id="(\d+)">([^<]+)<\/tg-emoji>/g, "![$2](tg://emoji?id=$1)");
+        return text;
+    }
+}
+exports.MarkdownV2Parser = MarkdownV2Parser;

package/extensions/net.d.ts

@@ -0,0 +1 @@
+export * from "net";

package/extensions/net.js

@@ -0,0 +1,17 @@
+"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("net"), exports);

package/extensions/socks.d.ts

@@ -0,0 +1 @@
+export * from "socks";

package/extensions/socks.js

@@ -0,0 +1,17 @@
+"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("socks"), exports);

package/index.d.ts

@@ -0,0 +1,14 @@
+export { Api } from "./tl";
+import * as tl from "./tl";
+export { TelegramClient } from "./client/TelegramClient";
+export { Connection } from "./network";
+export { version } from "./Version";
+export { Logger } from "./extensions/Logger";
+import * as utils from "./Utils";
+import * as errors from "./errors";
+import * as sessions from "./sessions";
+import * as extensions from "./extensions";
+import * as helpers from "./Helpers";
+import * as client from "./client";
+import * as password from "./Password";
+export { utils, errors, sessions, extensions, helpers, tl, password, client };

package/index.js

@@ -0,0 +1,62 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = exports.password = exports.tl = exports.helpers = exports.extensions = exports.sessions = exports.errors = exports.utils = exports.Logger = exports.version = exports.Connection = exports.TelegramClient = exports.Api = void 0;
+var tl_1 = require("./tl");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return tl_1.Api; } });
+const tl = __importStar(require("./tl"));
+exports.tl = tl;
+var TelegramClient_1 = require("./client/TelegramClient");
+Object.defineProperty(exports, "TelegramClient", { enumerable: true, get: function () { return TelegramClient_1.TelegramClient; } });
+var network_1 = require("./network");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return network_1.Connection; } });
+var Version_1 = require("./Version");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return Version_1.version; } });
+var Logger_1 = require("./extensions/Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
+const utils = __importStar(require("./Utils"));
+exports.utils = utils;
+const errors = __importStar(require("./errors"));
+exports.errors = errors;
+const sessions = __importStar(require("./sessions"));
+exports.sessions = sessions;
+const extensions = __importStar(require("./extensions"));
+exports.extensions = extensions;
+const helpers = __importStar(require("./Helpers"));
+exports.helpers = helpers;
+const client = __importStar(require("./client"));
+exports.client = client;
+const password = __importStar(require("./Password"));
+exports.password = password;

package/inspect.d.ts

@@ -0,0 +1 @@
+export { inspect } from "util";

package/inspect.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspect = void 0;
+var util_1 = require("util");
+Object.defineProperty(exports, "inspect", { enumerable: true, get: function () { return util_1.inspect; } });

package/network/Authenticator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Executes the authentication process with the Telegram servers.
+ * @param sender a connected {MTProtoPlainSender}.
+ * @param log
+ * @returns {Promise<{authKey: *, timeOffset: *}>}
+ */
+import { MTProtoPlainSender } from "./MTProtoPlainSender";
+import { AuthKey } from "../crypto/AuthKey";
+export declare function doAuthentication(sender: MTProtoPlainSender, log: any): Promise<{
+    authKey: AuthKey;
+    timeOffset: number;
+}>;

package/network/Authenticator.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doAuthentication = doAuthentication;
+const Helpers_1 = require("../Helpers");
+const tl_1 = require("../tl");
+const errors_1 = require("../errors");
+const Factorizator_1 = require("../crypto/Factorizator");
+const RSA_1 = require("../crypto/RSA");
+const IGE_1 = require("../crypto/IGE");
+const big_integer_1 = __importDefault(require("big-integer"));
+const extensions_1 = require("../extensions");
+const AuthKey_1 = require("../crypto/AuthKey");
+const RETRIES = 20;
+async function doAuthentication(sender, log) {
+    // Step 1 sending: PQ Request, endianness doesn't matter since it's random
+    let bytes = (0, Helpers_1.generateRandomBytes)(16);
+    const nonce = (0, Helpers_1.readBigIntFromBuffer)(bytes, false, true);
+    const resPQ = await sender.send(new tl_1.Api.ReqPqMulti({ nonce }));
+    log.debug("Starting authKey generation step 1");
+    if (!(resPQ instanceof tl_1.Api.ResPQ)) {
+        throw new errors_1.SecurityError(`Step 1 answer was ${resPQ}`);
+    }
+    if (resPQ.nonce.neq(nonce)) {
+        throw new errors_1.SecurityError("Step 1 invalid nonce from server");
+    }
+    const pq = (0, Helpers_1.readBigIntFromBuffer)(resPQ.pq, false, true);
+    log.debug("Finished authKey generation step 1");
+    // Step 2 sending: DH Exchange
+    const { p, q } = Factorizator_1.Factorizator.factorize(pq);
+    const pBuffer = (0, Helpers_1.getByteArray)(p);
+    const qBuffer = (0, Helpers_1.getByteArray)(q);
+    bytes = (0, Helpers_1.generateRandomBytes)(32);
+    const newNonce = (0, Helpers_1.readBigIntFromBuffer)(bytes, true, true);
+    const pqInnerData = new tl_1.Api.PQInnerData({
+        pq: (0, Helpers_1.getByteArray)(pq), // unsigned
+        p: pBuffer,
+        q: qBuffer,
+        nonce: resPQ.nonce,
+        serverNonce: resPQ.serverNonce,
+        newNonce,
+    }).getBytes();
+    if (pqInnerData.length > 144) {
+        throw new errors_1.SecurityError("Step 1 invalid nonce from server");
+    }
+    let targetFingerprint;
+    let targetKey;
+    for (const fingerprint of resPQ.serverPublicKeyFingerprints) {
+        targetKey = RSA_1._serverKeys.get(fingerprint.toString());
+        if (targetKey !== undefined) {
+            targetFingerprint = fingerprint;
+            break;
+        }
+    }
+    if (targetFingerprint === undefined || targetKey === undefined) {
+        throw new errors_1.SecurityError("Step 2 could not find a valid key for fingerprints");
+    }
+    // Value should be padded to be made 192 exactly
+    const padding = (0, Helpers_1.generateRandomBytes)(192 - pqInnerData.length);
+    const dataWithPadding = Buffer.concat([pqInnerData, padding]);
+    const dataPadReversed = Buffer.from(dataWithPadding).reverse();
+    let encryptedData;
+    for (let i = 0; i < RETRIES; i++) {
+        const tempKey = (0, Helpers_1.generateRandomBytes)(32);
+        const shaDigestKeyWithData = await (0, Helpers_1.sha256)(Buffer.concat([tempKey, dataWithPadding]));
+        const dataWithHash = Buffer.concat([
+            dataPadReversed,
+            shaDigestKeyWithData,
+        ]);
+        const ige = new IGE_1.IGE(tempKey, Buffer.alloc(32));
+        const aesEncrypted = ige.encryptIge(dataWithHash);
+        const tempKeyXor = (0, Helpers_1.bufferXor)(tempKey, await (0, Helpers_1.sha256)(aesEncrypted));
+        const keyAesEncrypted = Buffer.concat([tempKeyXor, aesEncrypted]);
+        const keyAesEncryptedInt = (0, Helpers_1.readBigIntFromBuffer)(keyAesEncrypted, false, false);
+        if (keyAesEncryptedInt.greaterOrEquals(targetKey.n)) {
+            log.debug("Aes key greater than RSA. retrying");
+            continue;
+        }
+        const encryptedDataBuffer = (0, Helpers_1.modExp)(keyAesEncryptedInt, (0, big_integer_1.default)(targetKey.e), targetKey.n);
+        encryptedData = (0, Helpers_1.readBufferFromBigInt)(encryptedDataBuffer, 256, false, false);
+        break;
+    }
+    if (encryptedData === undefined) {
+        throw new errors_1.SecurityError("Step 2 could create a secure encrypted key");
+    }
+    log.debug("Step 2 : Generated a secure aes encrypted data");
+    const serverDhParams = await sender.send(new tl_1.Api.ReqDHParams({
+        nonce: resPQ.nonce,
+        serverNonce: resPQ.serverNonce,
+        p: pBuffer,
+        q: qBuffer,
+        publicKeyFingerprint: targetFingerprint,
+        encryptedData,
+    }));
+    if (!(serverDhParams instanceof tl_1.Api.ServerDHParamsOk ||
+        serverDhParams instanceof tl_1.Api.ServerDHParamsFail)) {
+        throw new Error(`Step 2.1 answer was ${serverDhParams}`);
+    }
+    if (serverDhParams.nonce.neq(resPQ.nonce)) {
+        throw new errors_1.SecurityError("Step 2 invalid nonce from server");
+    }
+    if (serverDhParams.serverNonce.neq(resPQ.serverNonce)) {
+        throw new errors_1.SecurityError("Step 2 invalid server nonce from server");
+    }
+    if (serverDhParams instanceof tl_1.Api.ServerDHParamsFail) {
+        const sh = await (0, Helpers_1.sha1)((0, Helpers_1.toSignedLittleBuffer)(newNonce, 32).slice(4, 20));
+        const nnh = (0, Helpers_1.readBigIntFromBuffer)(sh, true, true);
+        if (serverDhParams.newNonceHash.neq(nnh)) {
+            throw new errors_1.SecurityError("Step 2 invalid DH fail nonce from server");
+        }
+    }
+    if (!(serverDhParams instanceof tl_1.Api.ServerDHParamsOk)) {
+        throw new Error(`Step 2.2 answer was ${serverDhParams}`);
+    }
+    log.debug("Finished authKey generation step 2");
+    log.debug("Starting authKey generation step 3");
+    // Step 3 sending: Complete DH Exchange
+    const { key, iv } = await (0, Helpers_1.generateKeyDataFromNonce)(resPQ.serverNonce, newNonce);
+    if (serverDhParams.encryptedAnswer.length % 16 !== 0) {
+        // See PR#453
+        throw new errors_1.SecurityError("Step 3 AES block size mismatch");
+    }
+    const ige = new IGE_1.IGE(key, iv);
+    const plainTextAnswer = ige.decryptIge(serverDhParams.encryptedAnswer);
+    const reader = new extensions_1.BinaryReader(plainTextAnswer);
+    reader.read(20); // hash sum
+    const serverDhInner = reader.tgReadObject();
+    if (!(serverDhInner instanceof tl_1.Api.ServerDHInnerData)) {
+        throw new Error(`Step 3 answer was ${serverDhInner}`);
+    }
+    if (serverDhInner.nonce.neq(resPQ.nonce)) {
+        throw new errors_1.SecurityError("Step 3 Invalid nonce in encrypted answer");
+    }
+    if (serverDhInner.serverNonce.neq(resPQ.serverNonce)) {
+        throw new errors_1.SecurityError("Step 3 Invalid server nonce in encrypted answer");
+    }
+    const dhPrime = (0, Helpers_1.readBigIntFromBuffer)(serverDhInner.dhPrime, false, false);
+    const ga = (0, Helpers_1.readBigIntFromBuffer)(serverDhInner.gA, false, false);
+    const timeOffset = serverDhInner.serverTime - Math.floor(new Date().getTime() / 1000);
+    const b = (0, Helpers_1.readBigIntFromBuffer)((0, Helpers_1.generateRandomBytes)(256), false, false);
+    const gb = (0, Helpers_1.modExp)((0, big_integer_1.default)(serverDhInner.g), b, dhPrime);
+    const gab = (0, Helpers_1.modExp)(ga, b, dhPrime);
+    // Prepare client DH Inner Data
+    const clientDhInner = new tl_1.Api.ClientDHInnerData({
+        nonce: resPQ.nonce,
+        serverNonce: resPQ.serverNonce,
+        retryId: big_integer_1.default.zero, // TODO Actual retry ID
+        gB: (0, Helpers_1.getByteArray)(gb, false),
+    }).getBytes();
+    const clientDdhInnerHashed = Buffer.concat([
+        await (0, Helpers_1.sha1)(clientDhInner),
+        clientDhInner,
+    ]);
+    // Encryption
+    const clientDhEncrypted = ige.encryptIge(clientDdhInnerHashed);
+    const dhGen = await sender.send(new tl_1.Api.SetClientDHParams({
+        nonce: resPQ.nonce,
+        serverNonce: resPQ.serverNonce,
+        encryptedData: clientDhEncrypted,
+    }));
+    const nonceTypes = [tl_1.Api.DhGenOk, tl_1.Api.DhGenRetry, tl_1.Api.DhGenFail];
+    // TS being weird again.
+    const nonceTypesString = ["DhGenOk", "DhGenRetry", "DhGenFail"];
+    if (!(dhGen instanceof nonceTypes[0] ||
+        dhGen instanceof nonceTypes[1] ||
+        dhGen instanceof nonceTypes[2])) {
+        throw new Error(`Step 3.1 answer was ${dhGen}`);
+    }
+    const { name } = dhGen.constructor;
+    if (dhGen.nonce.neq(resPQ.nonce)) {
+        throw new errors_1.SecurityError(`Step 3 invalid ${name} nonce from server`);
+    }
+    if (dhGen.serverNonce.neq(resPQ.serverNonce)) {
+        throw new errors_1.SecurityError(`Step 3 invalid ${name} server nonce from server`);
+    }
+    const authKey = new AuthKey_1.AuthKey();
+    await authKey.setKey((0, Helpers_1.getByteArray)(gab));
+    const nonceNumber = 1 + nonceTypesString.indexOf(dhGen.className);
+    const newNonceHash = await authKey.calcNewNonceHash(newNonce, nonceNumber);
+    // @ts-ignore
+    const dhHash = dhGen[`newNonceHash${nonceNumber}`];
+    if (dhHash.neq(newNonceHash)) {
+        throw new errors_1.SecurityError("Step 3 invalid new nonce hash");
+    }
+    if (!(dhGen instanceof tl_1.Api.DhGenOk)) {
+        throw new Error(`Step 3.2 answer was ${dhGen}`);
+    }
+    log.debug("Finished authKey generation step 3");
+    return { authKey, timeOffset };
+}

package/network/MTProtoPlainSender.d.ts

@@ -0,0 +1,19 @@
+import { Api } from "../tl";
+/**
+ * MTProto Mobile Protocol plain sender (https://core.telegram.org/mtproto/description#unencrypted-messages)
+ */
+export declare class MTProtoPlainSender {
+    private _state;
+    private _connection;
+    /**
+     * Initializes the MTProto plain sender.
+     * @param connection connection: the Connection to be used.
+     * @param loggers
+     */
+    constructor(connection: any, loggers: any);
+    /**
+     * Sends and receives the result for the given request.
+     * @param request
+     */
+    send(request: Api.AnyRequest): Promise<any>;
+}

package/network/MTProtoPlainSender.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.MTProtoPlainSender = void 0;
+/**
+ *  This module contains the class used to communicate with Telegram's servers
+ *  in plain text, when no authorization key has been created yet.
+ */
+const big_integer_1 = __importDefault(require("big-integer"));
+const MTProtoState_1 = require("./MTProtoState");
+const Helpers_1 = require("../Helpers");
+const errors_1 = require("../errors");
+const extensions_1 = require("../extensions");
+/**
+ * MTProto Mobile Protocol plain sender (https://core.telegram.org/mtproto/description#unencrypted-messages)
+ */
+class MTProtoPlainSender {
+    /**
+     * Initializes the MTProto plain sender.
+     * @param connection connection: the Connection to be used.
+     * @param loggers
+     */
+    constructor(connection, loggers) {
+        this._state = new MTProtoState_1.MTProtoState(undefined, loggers);
+        this._connection = connection;
+    }
+    /**
+     * Sends and receives the result for the given request.
+     * @param request
+     */
+    async send(request) {
+        let body = request.getBytes();
+        let msgId = this._state._getNewMsgId();
+        const m = (0, Helpers_1.toSignedLittleBuffer)(msgId, 8);
+        const b = Buffer.alloc(4);
+        b.writeInt32LE(body.length, 0);
+        const res = Buffer.concat([
+            Buffer.concat([Buffer.alloc(8), m, b]),
+            body,
+        ]);
+        await this._connection.send(res);
+        body = await this._connection.recv();
+        if (body.length < 8) {
+            throw new errors_1.InvalidBufferError(body);
+        }
+        const reader = new extensions_1.BinaryReader(body);
+        const authKeyId = reader.readLong();
+        if (authKeyId.neq((0, big_integer_1.default)(0))) {
+            throw new Error("Bad authKeyId");
+        }
+        msgId = reader.readLong();
+        if (msgId.eq((0, big_integer_1.default)(0))) {
+            throw new Error("Bad msgId");
+        }
+        /** ^ We should make sure that the read ``msg_id`` is greater
+         * than our own ``msg_id``. However, under some circumstances
+         * (bad system clock/working behind proxies) this seems to not
+         * be the case, which would cause endless assertion errors.
+         */
+        const length = reader.readInt();
+        if (length <= 0) {
+            throw new Error("Bad length");
+        }
+        /**
+         * We could read length bytes and use those in a new reader to read
+         * the next TLObject without including the padding, but since the
+         * reader isn't used for anything else after this, it's unnecessary.
+         */
+        return reader.tgReadObject();
+    }
+}
+exports.MTProtoPlainSender = MTProtoPlainSender;