teleproto 1.214.0

package/network/MTProtoState.d.ts

@@ -0,0 +1,102 @@
+import bigInt from "big-integer";
+import type { AuthKey } from "../crypto/AuthKey";
+import { TLMessage } from "../tl/core";
+import type { BinaryWriter } from "../extensions";
+export declare class MTProtoState {
+    private readonly authKey?;
+    private _log;
+    timeOffset: number;
+    salt: bigInt.BigInteger;
+    private id;
+    _sequence: number;
+    private _lastMsgId;
+    private msgIds;
+    private securityChecks;
+    /**
+     *
+     `telethon.network.mtprotosender.MTProtoSender` needs to hold a state
+     in order to be able to encrypt and decrypt incoming/outgoing messages,
+     as well as generating the message IDs. Instances of this class hold
+     together all the required information.
+
+     It doesn't make sense to use `telethon.sessions.abstract.Session` for
+     the sender because the sender should *not* be concerned about storing
+     this information to disk, as one may create as many senders as they
+     desire to any other data center, or some CDN. Using the same session
+     for all these is not a good idea as each need their own authkey, and
+     the concept of "copying" sessions with the unnecessary entities or
+     updates state for these connections doesn't make sense.
+
+     While it would be possible to have a `MTProtoPlainState` that does no
+     encryption so that it was usable through the `MTProtoLayer` and thus
+     avoid the need for a `MTProtoPlainSender`, the `MTProtoLayer` is more
+     focused to efficiency and this state is also more advanced (since it
+     supports gzipping and invoking after other message IDs). There are too
+     many methods that would be needed to make it convenient to use for the
+     authentication process, at which point the `MTProtoPlainSender` is better
+     * @param authKey
+     * @param loggers
+     * @param securityChecks
+     */
+    constructor(authKey?: AuthKey, loggers?: any, securityChecks?: boolean);
+    /**
+     * Resets the state
+     */
+    reset(): void;
+    /**
+     * Updates the message ID to a new one,
+     * used when the time offset changed.
+     * @param message
+     */
+    updateMessageId(message: any): void;
+    /**
+     * Calculate the key based on Telegram guidelines, specifying whether it's the client or not
+     * @param authKey
+     * @param msgKey
+     * @param client
+     * @returns {{iv: Buffer, key: Buffer}}
+     */
+    _calcKey(authKey: Buffer, msgKey: Buffer, client: boolean): Promise<{
+        key: Buffer<ArrayBuffer>;
+        iv: Buffer<ArrayBuffer>;
+    }>;
+    /**
+     * Writes a message containing the given data into buffer.
+     * Returns the message id.
+     * @param buffer
+     * @param data
+     * @param contentRelated
+     * @param afterId
+     */
+    writeDataAsMessage(buffer: BinaryWriter, data: Buffer, contentRelated: boolean, afterId?: bigInt.BigInteger): Promise<bigInt.BigInteger>;
+    /**
+     * Encrypts the given message data using the current authorization key
+     * following MTProto 2.0 guidelines core.telegram.org/mtproto/description.
+     * @param data
+     */
+    encryptMessageData(data: Buffer): Promise<Buffer<ArrayBuffer>>;
+    /**
+     * Inverse of `encrypt_message_data` for incoming server messages.
+     * @param body
+     */
+    decryptMessageData(body: Buffer): Promise<TLMessage>;
+    /**
+     * Generates a new unique message ID based on the current
+     * time (in ms) since epoch, applying a known time offset.
+     * @private
+     */
+    _getNewMsgId(): bigInt.BigInteger;
+    /**
+     * Updates the time offset to the correct
+     * one given a known valid message ID.
+     * @param correctMsgId {BigInteger}
+     */
+    updateTimeOffset(correctMsgId: bigInt.BigInteger): number;
+    /**
+     * Generates the next sequence number depending on whether
+     * it should be for a content-related query or not.
+     * @param contentRelated
+     * @private
+     */
+    _getSeqNo(contentRelated: boolean): number;
+}

package/network/MTProtoState.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MTProtoState = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const __1 = require("..");
+const tl_1 = require("../tl");
+const Helpers_1 = require("../Helpers");
+const core_1 = require("../tl/core");
+const extensions_1 = require("../extensions");
+const IGE_1 = require("../crypto/IGE");
+const errors_1 = require("../errors");
+class MTProtoState {
+    /**
+     *
+     `telethon.network.mtprotosender.MTProtoSender` needs to hold a state
+     in order to be able to encrypt and decrypt incoming/outgoing messages,
+     as well as generating the message IDs. Instances of this class hold
+     together all the required information.
+
+     It doesn't make sense to use `telethon.sessions.abstract.Session` for
+     the sender because the sender should *not* be concerned about storing
+     this information to disk, as one may create as many senders as they
+     desire to any other data center, or some CDN. Using the same session
+     for all these is not a good idea as each need their own authkey, and
+     the concept of "copying" sessions with the unnecessary entities or
+     updates state for these connections doesn't make sense.
+
+     While it would be possible to have a `MTProtoPlainState` that does no
+     encryption so that it was usable through the `MTProtoLayer` and thus
+     avoid the need for a `MTProtoPlainSender`, the `MTProtoLayer` is more
+     focused to efficiency and this state is also more advanced (since it
+     supports gzipping and invoking after other message IDs). There are too
+     many methods that would be needed to make it convenient to use for the
+     authentication process, at which point the `MTProtoPlainSender` is better
+     * @param authKey
+     * @param loggers
+     * @param securityChecks
+     */
+    constructor(authKey, loggers, securityChecks = true) {
+        this.authKey = authKey;
+        this._log = loggers;
+        this.timeOffset = 0;
+        this.salt = big_integer_1.default.zero;
+        this._sequence = 0;
+        this.id = this._lastMsgId = big_integer_1.default.zero;
+        this.msgIds = [];
+        this.securityChecks = securityChecks;
+        this.reset();
+    }
+    /**
+     * Resets the state
+     */
+    reset() {
+        // Session IDs can be random on every connection
+        this.id = __1.helpers.generateRandomLong(true);
+        this._sequence = 0;
+        this._lastMsgId = big_integer_1.default.zero;
+        this.msgIds = [];
+    }
+    /**
+     * Updates the message ID to a new one,
+     * used when the time offset changed.
+     * @param message
+     */
+    updateMessageId(message) {
+        message.msgId = this._getNewMsgId();
+    }
+    /**
+     * Calculate the key based on Telegram guidelines, specifying whether it's the client or not
+     * @param authKey
+     * @param msgKey
+     * @param client
+     * @returns {{iv: Buffer, key: Buffer}}
+     */
+    async _calcKey(authKey, msgKey, client) {
+        const x = client ? 0 : 8;
+        const [sha256a, sha256b] = await Promise.all([
+            (0, Helpers_1.sha256)(Buffer.concat([msgKey, authKey.slice(x, x + 36)])),
+            (0, Helpers_1.sha256)(Buffer.concat([authKey.slice(x + 40, x + 76), msgKey])),
+        ]);
+        const key = Buffer.concat([
+            sha256a.slice(0, 8),
+            sha256b.slice(8, 24),
+            sha256a.slice(24, 32),
+        ]);
+        const iv = Buffer.concat([
+            sha256b.slice(0, 8),
+            sha256a.slice(8, 24),
+            sha256b.slice(24, 32),
+        ]);
+        return { key, iv };
+    }
+    /**
+     * Writes a message containing the given data into buffer.
+     * Returns the message id.
+     * @param buffer
+     * @param data
+     * @param contentRelated
+     * @param afterId
+     */
+    async writeDataAsMessage(buffer, data, contentRelated, afterId) {
+        const msgId = this._getNewMsgId();
+        const seqNo = this._getSeqNo(contentRelated);
+        let body;
+        if (!afterId) {
+            body = await core_1.GZIPPacked.gzipIfSmaller(contentRelated, data);
+        }
+        else {
+            body = await core_1.GZIPPacked.gzipIfSmaller(contentRelated, new tl_1.Api.InvokeAfterMsg({
+                msgId: afterId,
+                query: {
+                    getBytes() {
+                        return data;
+                    },
+                },
+            }).getBytes());
+        }
+        const s = Buffer.alloc(4);
+        s.writeInt32LE(seqNo, 0);
+        const b = Buffer.alloc(4);
+        b.writeInt32LE(body.length, 0);
+        const m = (0, Helpers_1.toSignedLittleBuffer)(msgId, 8);
+        buffer.write(Buffer.concat([m, s, b]));
+        buffer.write(body);
+        return msgId;
+    }
+    /**
+     * Encrypts the given message data using the current authorization key
+     * following MTProto 2.0 guidelines core.telegram.org/mtproto/description.
+     * @param data
+     */
+    async encryptMessageData(data) {
+        if (!this.authKey) {
+            throw new Error("Auth key unset");
+        }
+        await this.authKey.waitForKey();
+        const authKey = this.authKey.getKey();
+        if (!authKey) {
+            throw new Error("Auth key unset");
+        }
+        if (!this.salt || !this.id || !authKey || !this.authKey.keyId) {
+            throw new Error("Unset params");
+        }
+        const s = (0, Helpers_1.toSignedLittleBuffer)(this.salt, 8);
+        const i = (0, Helpers_1.toSignedLittleBuffer)(this.id, 8);
+        data = Buffer.concat([Buffer.concat([s, i]), data]);
+        const padding = __1.helpers.generateRandomBytes(__1.helpers.mod(-(data.length + 12), 16) + 12);
+        // Being substr(what, offset, length); x = 0 for client
+        // "msg_key_large = SHA256(substr(auth_key, 88+x, 32) + pt + padding)"
+        const msgKeyLarge = await (0, Helpers_1.sha256)(Buffer.concat([authKey.slice(88, 88 + 32), data, padding]));
+        // "msg_key = substr (msg_key_large, 8, 16)"
+        const msgKey = msgKeyLarge.slice(8, 24);
+        const { iv, key } = await this._calcKey(authKey, msgKey, true);
+        const keyId = __1.helpers.readBufferFromBigInt(this.authKey.keyId, 8);
+        return Buffer.concat([
+            keyId,
+            msgKey,
+            new IGE_1.IGE(key, iv).encryptIge(Buffer.concat([data, padding])),
+        ]);
+    }
+    /**
+     * Inverse of `encrypt_message_data` for incoming server messages.
+     * @param body
+     */
+    async decryptMessageData(body) {
+        if (!this.authKey) {
+            throw new Error("Auth key unset");
+        }
+        if (body.length < 8) {
+            throw new errors_1.InvalidBufferError(body);
+        }
+        // TODO Check salt,sessionId, and sequenceNumber
+        const keyId = __1.helpers.readBigIntFromBuffer(body.slice(0, 8));
+        if (!this.authKey.keyId || keyId.neq(this.authKey.keyId)) {
+            throw new errors_1.SecurityError("Server replied with an invalid auth key");
+        }
+        const authKey = this.authKey.getKey();
+        if (!authKey) {
+            throw new errors_1.SecurityError("Unset AuthKey");
+        }
+        const msgKey = body.slice(8, 24);
+        const { iv, key } = await this._calcKey(authKey, msgKey, false);
+        body = new IGE_1.IGE(key, iv).decryptIge(body.slice(24));
+        // https://core.telegram.org/mtproto/security_guidelines
+        // Sections "checking sha256 hash" and "message length"
+        const ourKey = await (0, Helpers_1.sha256)(Buffer.concat([authKey.slice(96, 96 + 32), body]));
+        if (!msgKey.equals(ourKey.slice(8, 24))) {
+            throw new errors_1.SecurityError("Received msg_key doesn't match with expected one");
+        }
+        const reader = new extensions_1.BinaryReader(body);
+        reader.readLong(); // removeSalt
+        const serverId = reader.readLong();
+        if (serverId.neq(this.id)) {
+            // throw new SecurityError('Server replied with a wrong session ID');
+        }
+        const remoteMsgId = reader.readLong();
+        if (this.msgIds.includes(remoteMsgId.toString()) &&
+            this.securityChecks) {
+            throw new errors_1.SecurityError("Duplicate msgIds");
+        }
+        if (this.msgIds.length > 500) {
+            this.msgIds.shift();
+        }
+        this.msgIds.push(remoteMsgId.toString());
+        const remoteSequence = reader.readInt();
+        reader.readInt(); // msgLen for the inner object, padding ignored
+        // We could read msg_len 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.
+        const obj = reader.tgReadObject();
+        return new core_1.TLMessage(remoteMsgId, remoteSequence, obj);
+    }
+    /**
+     * Generates a new unique message ID based on the current
+     * time (in ms) since epoch, applying a known time offset.
+     * @private
+     */
+    _getNewMsgId() {
+        const now = new Date().getTime() / 1000 + this.timeOffset;
+        const nanoseconds = Math.floor((now - Math.floor(now)) * 1e9);
+        let newMsgId = (0, big_integer_1.default)(Math.floor(now))
+            .shiftLeft((0, big_integer_1.default)(32))
+            .or((0, big_integer_1.default)(nanoseconds).shiftLeft((0, big_integer_1.default)(2)));
+        if (this._lastMsgId.greaterOrEquals(newMsgId)) {
+            newMsgId = this._lastMsgId.add((0, big_integer_1.default)(4));
+        }
+        this._lastMsgId = newMsgId;
+        return newMsgId;
+    }
+    /**
+     * Updates the time offset to the correct
+     * one given a known valid message ID.
+     * @param correctMsgId {BigInteger}
+     */
+    updateTimeOffset(correctMsgId) {
+        const bad = this._getNewMsgId();
+        const old = this.timeOffset;
+        const now = Math.floor(new Date().getTime() / 1000);
+        const correct = correctMsgId.shiftRight((0, big_integer_1.default)(32)).toJSNumber();
+        this.timeOffset = correct - now;
+        if (this.timeOffset !== old) {
+            this._lastMsgId = big_integer_1.default.zero;
+            this._log.debug(`Updated time offset (old offset ${old}, bad ${bad}, good ${correctMsgId}, new ${this.timeOffset})`);
+        }
+        return this.timeOffset;
+    }
+    /**
+     * Generates the next sequence number depending on whether
+     * it should be for a content-related query or not.
+     * @param contentRelated
+     * @private
+     */
+    _getSeqNo(contentRelated) {
+        if (contentRelated) {
+            const result = this._sequence * 2 + 1;
+            this._sequence += 1;
+            return result;
+        }
+        else {
+            return this._sequence * 2;
+        }
+    }
+}
+exports.MTProtoState = MTProtoState;

package/network/RequestState.d.ts

@@ -0,0 +1,18 @@
+import bigInt from "big-integer";
+import Deferred from "../extensions/Deferred";
+import { Api } from "../tl";
+export declare class RequestState {
+    containerId?: bigInt.BigInteger;
+    msgId?: bigInt.BigInteger;
+    request: any;
+    data: Buffer;
+    after: any;
+    result: undefined;
+    finished: Deferred;
+    promise: Promise<unknown> | undefined;
+    resolve: (value?: any) => void;
+    reject: (reason?: any) => void;
+    constructor(request: Api.AnyRequest | Api.MsgsAck | Api.MsgsStateInfo);
+    isReady(): any;
+    resetPromise(): void;
+}

package/network/RequestState.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestState = void 0;
+const Deferred_1 = __importDefault(require("../extensions/Deferred"));
+class RequestState {
+    constructor(request) {
+        this.containerId = undefined;
+        this.msgId = undefined;
+        this.request = request;
+        this.data = request.getBytes();
+        this.after = undefined;
+        this.result = undefined;
+        this.finished = new Deferred_1.default();
+        this.resetPromise();
+    }
+    isReady() {
+        if (!this.after) {
+            return true;
+        }
+        return this.after.finished.promise;
+    }
+    resetPromise() {
+        var _a;
+        // Prevent stuck await
+        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+exports.RequestState = RequestState;

package/network/connection/Connection.d.ts

@@ -0,0 +1,69 @@
+import { Logger, PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+import { AsyncQueue } from "../../extensions";
+import { AbridgedPacketCodec } from "./TCPAbridged";
+import { FullPacketCodec } from "./TCPFull";
+import { ProxyInterface } from "./TCPMTProxy";
+interface ConnectionInterfaceParams {
+    ip: string;
+    port: number;
+    dcId: number;
+    loggers: Logger;
+    proxy?: ProxyInterface;
+    socket: typeof PromisedNetSockets | typeof PromisedWebSockets;
+    testServers: boolean;
+}
+/**
+ * The `Connection` class is a wrapper around ``asyncio.open_connection``.
+ *
+ * Subclasses will implement different transport modes as atomic operations,
+ * which this class eases doing since the exposed interface simply puts and
+ * gets complete data payloads to and from queues.
+ *
+ * The only error that will raise from send and receive methods is
+ * ``ConnectionError``, which will raise when attempting to send if
+ * the client is disconnected (includes remote disconnections).
+ */
+declare class Connection {
+    PacketCodecClass?: typeof AbridgedPacketCodec | typeof FullPacketCodec;
+    readonly _ip: string;
+    readonly _port: number;
+    _dcId: number;
+    _log: Logger;
+    _proxy?: ProxyInterface;
+    _connected: boolean;
+    private _sendTask?;
+    private _recvTask?;
+    protected _codec: any;
+    protected _obfuscation: any;
+    _sendArray: AsyncQueue;
+    _recvArray: AsyncQueue;
+    private _abortController;
+    socket: PromisedNetSockets | PromisedWebSockets;
+    _testServers: boolean;
+    constructor({ ip, port, dcId, loggers, proxy, socket, testServers, }: ConnectionInterfaceParams);
+    _connect(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(): Promise<any>;
+    _sendLoop(): Promise<void>;
+    isConnected(): boolean;
+    _recvLoop(): Promise<void>;
+    _initConn(): Promise<void>;
+    _send(data: Buffer): Promise<void>;
+    _recv(): Promise<any>;
+    toString(): string;
+}
+declare class ObfuscatedConnection extends Connection {
+    ObfuscatedIO: any;
+    _initConn(): Promise<void>;
+    _send(data: Buffer): Promise<void>;
+    _recv(): Promise<any>;
+}
+declare class PacketCodec {
+    private _conn;
+    constructor(connection: Buffer);
+    encodePacket(data: Buffer): void;
+    readPacket(reader: PromisedNetSockets | PromisedWebSockets): Promise<Buffer>;
+}
+export { Connection, PacketCodec, ObfuscatedConnection };

package/network/connection/Connection.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObfuscatedConnection = exports.PacketCodec = exports.Connection = void 0;
+const extensions_1 = require("../../extensions");
+/**
+ * The `Connection` class is a wrapper around ``asyncio.open_connection``.
+ *
+ * Subclasses will implement different transport modes as atomic operations,
+ * which this class eases doing since the exposed interface simply puts and
+ * gets complete data payloads to and from queues.
+ *
+ * The only error that will raise from send and receive methods is
+ * ``ConnectionError``, which will raise when attempting to send if
+ * the client is disconnected (includes remote disconnections).
+ */
+class Connection {
+    constructor({ ip, port, dcId, loggers, proxy, socket, testServers, }) {
+        this._ip = ip;
+        this._port = port;
+        this._dcId = dcId;
+        this._log = loggers;
+        this._proxy = proxy;
+        this._connected = false;
+        this._sendTask = undefined;
+        this._recvTask = undefined;
+        this._codec = undefined;
+        this._obfuscation = undefined; // TcpObfuscated and MTProxy
+        this._sendArray = new extensions_1.AsyncQueue();
+        this._recvArray = new extensions_1.AsyncQueue();
+        this._abortController = new AbortController();
+        this.socket = new socket(proxy);
+        this._testServers = testServers;
+    }
+    async _connect() {
+        this._log.debug("Connecting");
+        this._codec = new this.PacketCodecClass(this);
+        await this.socket.connect(this._port, this._ip, this._testServers);
+        this._log.debug("Finished connecting");
+        // await this.socket.connect({host: this._ip, port: this._port});
+        await this._initConn();
+    }
+    async connect() {
+        // Reset abort controller to have a fresh signal
+        this._abortController = new AbortController();
+        await this._connect();
+        this._connected = true;
+        if (!this._sendTask) {
+            this._sendTask = this._sendLoop();
+        }
+        this._recvTask = this._recvLoop();
+    }
+    async disconnect() {
+        if (!this._connected) {
+            return;
+        }
+        this._connected = false;
+        // Signal abort to any pending operations
+        this._abortController.abort();
+        void this._recvArray.push(undefined);
+        await this.socket.close();
+    }
+    async send(data) {
+        if (!this._connected) {
+            throw new Error("Not connected");
+        }
+        await this._sendArray.push(data);
+    }
+    async recv() {
+        while (this._connected) {
+            const result = await this._recvArray.pop();
+            // null = sentinel value = keep trying
+            if (result) {
+                return result;
+            }
+        }
+        throw new Error("Not connected");
+    }
+    async _sendLoop() {
+        try {
+            while (this._connected) {
+                const data = await this._sendArray.pop();
+                if (!data) {
+                    this._sendTask = undefined;
+                    return;
+                }
+                await this._send(data);
+            }
+        }
+        catch (e) {
+            this._log.info("The server closed the connection while sending");
+        }
+    }
+    isConnected() {
+        return this._connected;
+    }
+    async _recvLoop() {
+        let data;
+        while (this._connected) {
+            try {
+                data = await this._recv();
+                if (!data) {
+                    throw new Error("no data received");
+                }
+            }
+            catch (e) {
+                this._log.info("connection closed");
+                // await this._recvArray.push()
+                this.disconnect();
+                return;
+            }
+            await this._recvArray.push(data);
+        }
+    }
+    async _initConn() {
+        if (this._codec.tag) {
+            await this.socket.write(this._codec.tag);
+        }
+    }
+    async _send(data) {
+        const encodedPacket = this._codec.encodePacket(data);
+        this.socket.write(encodedPacket);
+    }
+    async _recv() {
+        return await this._codec.readPacket(this.socket);
+    }
+    toString() {
+        return `${this._ip}:${this._port}/${this.constructor.name.replace("Connection", "")}`;
+    }
+}
+exports.Connection = Connection;
+class ObfuscatedConnection extends Connection {
+    constructor() {
+        super(...arguments);
+        this.ObfuscatedIO = undefined;
+    }
+    async _initConn() {
+        this._obfuscation = new this.ObfuscatedIO(this);
+        await this._obfuscation.initHeader();
+        this.socket.write(this._obfuscation.header);
+    }
+    async _send(data) {
+        this._obfuscation.write(this._codec.encodePacket(data));
+    }
+    async _recv() {
+        return await this._codec.readPacket(this._obfuscation);
+    }
+}
+exports.ObfuscatedConnection = ObfuscatedConnection;
+class PacketCodec {
+    constructor(connection) {
+        this._conn = connection;
+    }
+    encodePacket(data) {
+        throw new Error("Not Implemented");
+        // Override
+    }
+    async readPacket(reader) {
+        // override
+        throw new Error("Not Implemented");
+    }
+}
+exports.PacketCodec = PacketCodec;

package/network/connection/TCPAbridged.d.ts

@@ -0,0 +1,19 @@
+import { Connection, PacketCodec } from "./Connection";
+import type { PromisedNetSockets, PromisedWebSockets } from "../../extensions";
+export declare class AbridgedPacketCodec extends PacketCodec {
+    static tag: Buffer<ArrayBuffer>;
+    static obfuscateTag: Buffer<ArrayBuffer>;
+    private tag;
+    obfuscateTag: Buffer;
+    constructor(props: any);
+    encodePacket(data: Buffer): Buffer<ArrayBuffer>;
+    readPacket(reader: PromisedNetSockets | PromisedWebSockets): Promise<Buffer>;
+}
+/**
+ * This is the mode with the lowest overhead, as it will
+ * only require 1 byte if the packet length is less than
+ * 508 bytes (127 << 2, which is very common).
+ */
+export declare class ConnectionTCPAbridged extends Connection {
+    PacketCodecClass: typeof AbridgedPacketCodec;
+}