@armatofik/tgsnake-core 1.0.0

package/lib/src/connection/TCP/TCPAbridged.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPAbridged = void 0;
+const platform_node_js_1 = require("../../platform.node.js");
+const tcp_js_1 = require("./tcp.js");
+const helpers_js_1 = require("../../helpers.js");
+class TCPAbridged extends tcp_js_1.TCP {
+    constructor() {
+        super();
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        return await super.send(platform_node_js_1.Buffer.from('ef', 'hex'));
+    }
+    async send(data) {
+        const length = Math.round(platform_node_js_1.Buffer.byteLength(data) / 4);
+        if (length <= 126) {
+            const mark = platform_node_js_1.Buffer.from([length]);
+            return await super.send(platform_node_js_1.Buffer.concat([mark, data]));
+        }
+        else {
+            return await super.send(platform_node_js_1.Buffer.concat([
+                platform_node_js_1.Buffer.concat([
+                    platform_node_js_1.Buffer.from('7f', 'hex'),
+                    (0, helpers_js_1.bigintToBuffer)(BigInt(length), 3),
+                ]),
+                data,
+            ]));
+        }
+    }
+    async recv(_length = 0) {
+        let length = await super.recv(1);
+        if (!length)
+            return;
+        if (length.equals(platform_node_js_1.Buffer.from('7f', 'hex'))) {
+            length = await super.recv(3);
+            if (!length)
+                return;
+            return await super.recv(platform_node_js_1.Buffer.concat([
+                length,
+                platform_node_js_1.Buffer.alloc(1),
+            ]).readInt32LE(0) * 4);
+        }
+        return await super.recv(length[0] * 4);
+    }
+}
+exports.TCPAbridged = TCPAbridged;

package/lib/src/connection/TCP/TCPAbridgedO.d.ts

@@ -0,0 +1,12 @@
+import { TCP } from './tcp.js';
+import { Buffer } from '../../platform.node.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCPAbridgedO extends TCP {
+    private _reserved;
+    private _encryptor;
+    private _decryptor;
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, dcId?: number): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(_length?: number): Promise<Buffer<ArrayBuffer> | undefined>;
+}

package/lib/src/connection/TCP/TCPAbridgedO.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPAbridgedO = void 0;
+const tcp_js_1 = require("./tcp.js");
+const helpers_js_1 = require("../../helpers.js");
+const platform_node_js_1 = require("../../platform.node.js");
+const Aes_js_1 = require("../../crypto/Aes.js");
+class TCPAbridgedO extends tcp_js_1.TCP {
+    _reserved;
+    _encryptor;
+    _decryptor;
+    constructor() {
+        super();
+        this._reserved = [
+            platform_node_js_1.Buffer.from('HEAD'),
+            platform_node_js_1.Buffer.from('POST'),
+            platform_node_js_1.Buffer.from('GET'),
+            platform_node_js_1.Buffer.from('OPTI'),
+            platform_node_js_1.Buffer.from('eeeeeeee', 'hex'),
+        ];
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        let nonce;
+        if (proxy && 'secret' in proxy && 'port' in proxy && 'server' in proxy && dcId) {
+            let secret = typeof proxy.secret === 'string'
+                ? (0, helpers_js_1.normalizeSecretString)(proxy.secret)
+                : platform_node_js_1.Buffer.from(proxy.secret);
+            secret =
+                platform_node_js_1.Buffer.byteLength(secret) === 17 && secret[0] === 0xdd
+                    ? secret.subarray(1)
+                    : secret;
+            while (true) {
+                nonce = platform_node_js_1.crypto.randomBytes(64);
+                if (!platform_node_js_1.Buffer.from([nonce[0]]).equals(platform_node_js_1.Buffer.from('ef', 'hex')) &&
+                    !(0, helpers_js_1.includesBuffer)(this._reserved, nonce) &&
+                    !nonce.subarray(4, 8).equals(platform_node_js_1.Buffer.alloc(4))) {
+                    nonce[56] =
+                        nonce[57] =
+                            nonce[58] =
+                                nonce[59] =
+                                    0xef;
+                    break;
+                }
+            }
+            const temp = (0, helpers_js_1.sliceBuffer)(nonce, 55, 7, -1);
+            const encryptionKey = sha256(platform_node_js_1.Buffer.concat([
+                nonce.subarray(8, 40),
+                secret,
+            ]));
+            const encryptionIv = nonce.subarray(40, 56);
+            const decryptionKey = sha256(platform_node_js_1.Buffer.concat([
+                temp.subarray(0, 32),
+                secret,
+            ]));
+            const decryptionIv = temp.subarray(32, 48);
+            this._encryptor = (0, Aes_js_1.ctr256Cipher)(encryptionKey, encryptionIv);
+            this._decryptor = (0, Aes_js_1.ctr256Cipher)(decryptionKey, decryptionIv);
+            const _dcId = platform_node_js_1.Buffer.alloc(2);
+            _dcId.writeInt8(dcId, 0);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 60),
+                _dcId,
+                nonce.subarray(62),
+            ]);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 56),
+                this._encryptor(nonce).subarray(56, 64),
+            ]);
+        }
+        else {
+            while (true) {
+                nonce = platform_node_js_1.crypto.randomBytes(64);
+                if (!platform_node_js_1.Buffer.from([nonce[0]]).equals(platform_node_js_1.Buffer.from('ef', 'hex')) &&
+                    !(0, helpers_js_1.includesBuffer)(this._reserved, nonce) &&
+                    !nonce.subarray(4, 8).equals(platform_node_js_1.Buffer.alloc(4))) {
+                    nonce[56] =
+                        nonce[57] =
+                            nonce[58] =
+                                nonce[59] =
+                                    0xef;
+                    break;
+                }
+            }
+            const temp = (0, helpers_js_1.sliceBuffer)(nonce, 55, 7, -1);
+            const encryptionKey = nonce.subarray(8, 40);
+            const encryptionIv = nonce.subarray(40, 56);
+            const decryptionKey = temp.subarray(0, 32);
+            const decryptionIv = temp.subarray(32, 48);
+            this._encryptor = (0, Aes_js_1.ctr256Cipher)(encryptionKey, encryptionIv);
+            this._decryptor = (0, Aes_js_1.ctr256Cipher)(decryptionKey, decryptionIv);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 56),
+                this._encryptor(nonce).subarray(56, 64),
+            ]);
+        }
+        await super.send(nonce);
+    }
+    async send(data) {
+        const length = Math.round(platform_node_js_1.Buffer.byteLength(data) / 4);
+        if (length <= 126) {
+            return await super.send(this._encryptor(platform_node_js_1.Buffer.concat([
+                platform_node_js_1.Buffer.from([length]),
+                data,
+            ])));
+        }
+        else {
+            return await super.send(this._encryptor(platform_node_js_1.Buffer.concat([
+                platform_node_js_1.Buffer.concat([
+                    platform_node_js_1.Buffer.from('7f', 'hex'),
+                    (0, helpers_js_1.bigintToBuffer)(BigInt(length), 3),
+                ]),
+                data,
+            ])));
+        }
+    }
+    async recv(_length = 0) {
+        let length = await super.recv(1);
+        if (!length)
+            return;
+        length = platform_node_js_1.Buffer.from(this._decryptor(length));
+        if (length.equals(platform_node_js_1.Buffer.from('7f', 'hex'))) {
+            length = await super.recv(3);
+            if (!length)
+                return;
+            length = platform_node_js_1.Buffer.from(this._decryptor(length));
+            return platform_node_js_1.Buffer.from(this._decryptor((await super.recv(platform_node_js_1.Buffer.concat([
+                length,
+                platform_node_js_1.Buffer.alloc(1),
+            ]).readInt32LE(0) * 4))));
+        }
+        return platform_node_js_1.Buffer.from(this._decryptor((await super.recv(length[0] * 4))));
+    }
+}
+exports.TCPAbridgedO = TCPAbridgedO;
+function sha256(data) {
+    const hash = platform_node_js_1.crypto.createHash('sha256');
+    hash.update(data);
+    return hash.digest();
+}

package/lib/src/connection/TCP/TCPFull.d.ts

@@ -0,0 +1,10 @@
+import { Buffer } from '../../platform.node.js';
+import { TCP } from './tcp.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCPFull extends TCP {
+    private _seq;
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, dcId?: number): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(_length?: number): Promise<Buffer<ArrayBufferLike> | undefined>;
+}

package/lib/src/connection/TCP/TCPFull.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPFull = void 0;
+const platform_node_js_1 = require("../../platform.node.js");
+const tcp_js_1 = require("./tcp.js");
+const helpers_js_1 = require("../../helpers.js");
+class TCPFull extends tcp_js_1.TCP {
+    _seq;
+    constructor() {
+        super();
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        this._seq = 0;
+    }
+    async send(data) {
+        const allocSum = platform_node_js_1.Buffer.alloc(8);
+        allocSum.writeInt32LE(platform_node_js_1.Buffer.byteLength(data) + 12, 0);
+        allocSum.writeInt32LE(this._seq, 4);
+        data = platform_node_js_1.Buffer.concat([allocSum, data]);
+        const crc = (0, helpers_js_1.crc32)(data);
+        const bcrc = platform_node_js_1.Buffer.alloc(4);
+        bcrc.writeUInt32LE(crc, 0);
+        data = platform_node_js_1.Buffer.concat([data, bcrc]);
+        this._seq += 1;
+        await super.send(data);
+    }
+    async recv(_length = 0) {
+        const length = await super.recv(4);
+        if (!length)
+            return;
+        let packet = await super.recv(length.readInt32LE(0) - 4);
+        if (!packet)
+            return;
+        packet = platform_node_js_1.Buffer.concat([length, packet]);
+        const checksum = packet.subarray(-4);
+        packet = packet.subarray(0, -4);
+        if ((0, helpers_js_1.crc32)(packet) !== checksum.readUInt32LE(0))
+            return;
+        return packet.subarray(8);
+    }
+}
+exports.TCPFull = TCPFull;

package/lib/src/connection/TCP/TCPIntermediate.d.ts

@@ -0,0 +1,9 @@
+import { Buffer } from '../../platform.node.js';
+import { TCP } from './tcp.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCPIntermediate extends TCP {
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, dcId?: number): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(_length?: number): Promise<Buffer<ArrayBufferLike> | undefined>;
+}

package/lib/src/connection/TCP/TCPIntermediate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPIntermediate = void 0;
+const platform_node_js_1 = require("../../platform.node.js");
+const tcp_js_1 = require("./tcp.js");
+class TCPIntermediate extends tcp_js_1.TCP {
+    constructor() {
+        super();
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        await super.send(platform_node_js_1.Buffer.concat([
+            platform_node_js_1.Buffer.from('ee', 'hex'),
+            platform_node_js_1.Buffer.from('ee', 'hex'),
+            platform_node_js_1.Buffer.from('ee', 'hex'),
+            platform_node_js_1.Buffer.from('ee', 'hex'),
+        ]));
+    }
+    async send(data) {
+        const allocLength = platform_node_js_1.Buffer.alloc(4);
+        allocLength.writeInt32LE(platform_node_js_1.Buffer.byteLength(data), 0);
+        await super.send(platform_node_js_1.Buffer.concat([allocLength, data]));
+    }
+    async recv(_length = 0) {
+        const length = await super.recv(4);
+        if (!length)
+            return;
+        return await super.recv(length.readInt32LE(0));
+    }
+}
+exports.TCPIntermediate = TCPIntermediate;

package/lib/src/connection/TCP/TCPIntermediateO.d.ts

@@ -0,0 +1,12 @@
+import { TCP } from './tcp.js';
+import { Buffer } from '../../platform.node.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCPIntermediateO extends TCP {
+    private _reserved;
+    private _encryptor;
+    private _decryptor;
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, dcId?: number): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(_length?: number): Promise<Buffer<ArrayBufferLike> | undefined>;
+}

package/lib/src/connection/TCP/TCPIntermediateO.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPIntermediateO = void 0;
+const tcp_js_1 = require("./tcp.js");
+const helpers_js_1 = require("../../helpers.js");
+const platform_node_js_1 = require("../../platform.node.js");
+const Aes_js_1 = require("../../crypto/Aes.js");
+const index_js_1 = require("../../raw/core/index.js");
+class TCPIntermediateO extends tcp_js_1.TCP {
+    _reserved;
+    _encryptor;
+    _decryptor;
+    constructor() {
+        super();
+        this._reserved = [
+            platform_node_js_1.Buffer.from('HEAD'),
+            platform_node_js_1.Buffer.from('POST'),
+            platform_node_js_1.Buffer.from('GET'),
+            platform_node_js_1.Buffer.from('OPTI'),
+            platform_node_js_1.Buffer.from('eeeeeeee', 'hex'),
+        ];
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        let nonce;
+        if (proxy && 'secret' in proxy && 'port' in proxy && 'server' in proxy && dcId) {
+            let secret = typeof proxy.secret === 'string'
+                ? (0, helpers_js_1.normalizeSecretString)(proxy.secret)
+                : platform_node_js_1.Buffer.from(proxy.secret);
+            secret =
+                platform_node_js_1.Buffer.byteLength(secret) === 17 && secret[0] === 0xdd
+                    ? secret.subarray(1)
+                    : secret;
+            while (true) {
+                nonce = platform_node_js_1.crypto.randomBytes(64);
+                if (!platform_node_js_1.Buffer.from([nonce[0]]).equals(platform_node_js_1.Buffer.from('ef', 'hex')) &&
+                    !(0, helpers_js_1.includesBuffer)(this._reserved, nonce) &&
+                    !nonce.subarray(4, 8).equals(platform_node_js_1.Buffer.alloc(4))) {
+                    nonce[56] =
+                        nonce[57] =
+                            nonce[58] =
+                                nonce[59] =
+                                    0xee;
+                    break;
+                }
+            }
+            const temp = (0, helpers_js_1.sliceBuffer)(nonce, 55, 7, -1);
+            const encryptionKey = sha256(platform_node_js_1.Buffer.concat([
+                nonce.subarray(8, 40),
+                secret,
+            ]));
+            const encryptionIv = nonce.subarray(40, 56);
+            const decryptionIv = sha256(platform_node_js_1.Buffer.concat([
+                temp.subarray(0, 32),
+                secret,
+            ]));
+            const decryptionKey = temp.subarray(32, 48);
+            this._encryptor = (0, Aes_js_1.ctr256Cipher)(encryptionKey, encryptionIv);
+            this._decryptor = (0, Aes_js_1.ctr256Cipher)(decryptionKey, decryptionIv);
+            const _dcId = platform_node_js_1.Buffer.alloc(2);
+            _dcId.writeInt8(dcId, 0);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 60),
+                _dcId,
+                nonce.subarray(62),
+            ]);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 56),
+                this._encryptor(nonce).subarray(56, 64),
+            ]);
+        }
+        else {
+            while (true) {
+                nonce = platform_node_js_1.crypto.randomBytes(64);
+                if (!platform_node_js_1.Buffer.from([nonce[0]]).equals(platform_node_js_1.Buffer.from('ef', 'hex')) &&
+                    !(0, helpers_js_1.includesBuffer)(this._reserved, nonce) &&
+                    !nonce.subarray(4, 8).equals(platform_node_js_1.Buffer.alloc(4))) {
+                    nonce[56] =
+                        nonce[57] =
+                            nonce[58] =
+                                nonce[59] =
+                                    0xee;
+                    break;
+                }
+            }
+            const temp = (0, helpers_js_1.sliceBuffer)(nonce, 55, 7, -1);
+            const encryptionKey = nonce.subarray(8, 40);
+            const encryptionIv = nonce.subarray(40, 56);
+            const decryptionKey = temp.subarray(0, 32);
+            const decryptionIv = temp.subarray(32, 48);
+            this._encryptor = (0, Aes_js_1.ctr256Cipher)(encryptionKey, encryptionIv);
+            this._decryptor = (0, Aes_js_1.ctr256Cipher)(decryptionKey, decryptionIv);
+            nonce = platform_node_js_1.Buffer.concat([
+                nonce.subarray(0, 56),
+                this._encryptor(nonce).subarray(56, 64),
+            ]);
+        }
+        await super.send(nonce);
+    }
+    async send(data) {
+        const payload = this._encryptor(platform_node_js_1.Buffer.concat([
+            index_js_1.Primitive.Int.write(platform_node_js_1.Buffer.byteLength(data)),
+            data,
+        ]));
+        return await super.send(payload);
+    }
+    async recv(_length = 0) {
+        let length = await super.recv(4);
+        if (!length)
+            return;
+        length = this._decryptor(length);
+        const data = await super.recv(length.readInt32LE(0));
+        if (!data)
+            return;
+        return this._decryptor(data);
+    }
+}
+exports.TCPIntermediateO = TCPIntermediateO;
+function sha256(data) {
+    const hash = platform_node_js_1.crypto.createHash('sha256');
+    hash.update(data);
+    return hash.digest();
+}

package/lib/src/connection/TCP/TCPPaddedIntermediate.d.ts

@@ -0,0 +1,9 @@
+import { Buffer } from '../../platform.node.js';
+import { TCP } from './tcp.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCPPaddedIntermediate extends TCP {
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, dcId?: number): Promise<void>;
+    send(data: Buffer): Promise<void>;
+    recv(_length?: number): Promise<Buffer<ArrayBufferLike> | undefined>;
+}

package/lib/src/connection/TCP/TCPPaddedIntermediate.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPPaddedIntermediate = void 0;
+const platform_node_js_1 = require("../../platform.node.js");
+const tcp_js_1 = require("./tcp.js");
+class TCPPaddedIntermediate extends tcp_js_1.TCP {
+    constructor() {
+        super();
+    }
+    async connect(ip, port, proxy, dcId) {
+        await super.connect(ip, port, proxy, dcId);
+        await super.send(platform_node_js_1.Buffer.concat([
+            platform_node_js_1.Buffer.from('dd', 'hex'),
+            platform_node_js_1.Buffer.from('dd', 'hex'),
+            platform_node_js_1.Buffer.from('dd', 'hex'),
+            platform_node_js_1.Buffer.from('dd', 'hex'),
+        ]));
+    }
+    async send(data) {
+        data = platform_node_js_1.Buffer.concat([
+            data,
+            platform_node_js_1.Buffer.alloc(platform_node_js_1.Buffer.byteLength(data) % 4),
+        ]);
+        const allocLength = platform_node_js_1.Buffer.alloc(4);
+        allocLength.writeInt32LE(platform_node_js_1.Buffer.byteLength(data), 0);
+        await super.send(platform_node_js_1.Buffer.concat([allocLength, data]));
+    }
+    async recv(_length = 0) {
+        const length = await super.recv(4);
+        if (!length)
+            return;
+        const data = await super.recv(length.readInt32LE(0));
+        if (!data)
+            return;
+        return data.subarray(0, platform_node_js_1.Buffer.byteLength(data) - (platform_node_js_1.Buffer.byteLength(data) % 4));
+    }
+}
+exports.TCPPaddedIntermediate = TCPPaddedIntermediate;

package/lib/src/connection/TCP/index.d.ts

@@ -0,0 +1,7 @@
+export { TCP } from './tcp.js';
+export { TCPAbridged } from './TCPAbridged.js';
+export { TCPAbridgedO } from './TCPAbridgedO.js';
+export { TCPFull } from './TCPFull.js';
+export { TCPIntermediate } from './TCPIntermediate.js';
+export { TCPIntermediateO } from './TCPIntermediateO.js';
+export { TCPPaddedIntermediate } from './TCPPaddedIntermediate.js';

package/lib/src/connection/TCP/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPPaddedIntermediate = exports.TCPIntermediateO = exports.TCPIntermediate = exports.TCPFull = exports.TCPAbridgedO = exports.TCPAbridged = exports.TCP = void 0;
+var tcp_js_1 = require("./tcp.js");
+Object.defineProperty(exports, "TCP", { enumerable: true, get: function () { return tcp_js_1.TCP; } });
+var TCPAbridged_js_1 = require("./TCPAbridged.js");
+Object.defineProperty(exports, "TCPAbridged", { enumerable: true, get: function () { return TCPAbridged_js_1.TCPAbridged; } });
+var TCPAbridgedO_js_1 = require("./TCPAbridgedO.js");
+Object.defineProperty(exports, "TCPAbridgedO", { enumerable: true, get: function () { return TCPAbridgedO_js_1.TCPAbridgedO; } });
+var TCPFull_js_1 = require("./TCPFull.js");
+Object.defineProperty(exports, "TCPFull", { enumerable: true, get: function () { return TCPFull_js_1.TCPFull; } });
+var TCPIntermediate_js_1 = require("./TCPIntermediate.js");
+Object.defineProperty(exports, "TCPIntermediate", { enumerable: true, get: function () { return TCPIntermediate_js_1.TCPIntermediate; } });
+var TCPIntermediateO_js_1 = require("./TCPIntermediateO.js");
+Object.defineProperty(exports, "TCPIntermediateO", { enumerable: true, get: function () { return TCPIntermediateO_js_1.TCPIntermediateO; } });
+var TCPPaddedIntermediate_js_1 = require("./TCPPaddedIntermediate.js");
+Object.defineProperty(exports, "TCPPaddedIntermediate", { enumerable: true, get: function () { return TCPPaddedIntermediate_js_1.TCPPaddedIntermediate; } });

package/lib/src/connection/TCP/tcp.d.ts

@@ -0,0 +1,17 @@
+import { Buffer } from '../../platform.node.js';
+import type { ProxyInterface } from '../connection.js';
+export declare class TCP {
+    private _socks;
+    private _task;
+    private _mutex;
+    connected: boolean;
+    constructor();
+    connect(ip: string, port: number, proxy?: ProxyInterface, _dcId?: number): Promise<void>;
+    close(): Promise<boolean | undefined>;
+    send(data: Buffer): Promise<void>;
+    recv(length?: number): Promise<Buffer<ArrayBufferLike> | undefined>;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}

package/lib/src/connection/TCP/tcp.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCP = void 0;
+const WebSocket_js_1 = require("../WebSocket.js");
+const platform_node_js_1 = require("../../platform.node.js");
+const Timeout_js_1 = require("../../Timeout.js");
+const helpers_js_1 = require("../../helpers.js");
+class TCP {
+    _socks;
+    _task;
+    _mutex = new platform_node_js_1.Mutex();
+    connected;
+    constructor() {
+        this._task = new Timeout_js_1.Timeout();
+        this._socks = new WebSocket_js_1.Socket(10 * 1000);
+    }
+    async connect(ip, port, proxy, _dcId) {
+        const release = await this._mutex.acquire();
+        try {
+            await this._socks.connect(ip, port, proxy);
+        }
+        finally {
+            release();
+        }
+    }
+    async close() {
+        await this._task.clear();
+        await (0, helpers_js_1.sleep)(1);
+        if (!this._socks)
+            return;
+        return await this._socks.destroy();
+    }
+    async send(data) {
+        const release = await this._mutex.acquire();
+        try {
+            await this._socks.send(data);
+        }
+        finally {
+            release();
+        }
+    }
+    async recv(length = 0) {
+        let data = platform_node_js_1.Buffer.alloc(0);
+        while (platform_node_js_1.Buffer.byteLength(data) < length) {
+            const chunk = await this._task.run(this._socks.read(length - platform_node_js_1.Buffer.byteLength(data)), this._socks.timeout, () => { });
+            if (chunk) {
+                data = platform_node_js_1.Buffer.concat([data, chunk]);
+            }
+            else {
+                return;
+            }
+        }
+        return data;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (this.hasOwnProperty(key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    [Symbol.for('Deno.customInspect')]() {
+        return String((0, platform_node_js_1.inspect)(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    toJSON() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (this.hasOwnProperty(key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.TCP = TCP;

package/lib/src/connection/WebSocket.d.ts

@@ -0,0 +1,21 @@
+import { Buffer } from '../platform.node.js';
+import type { ProxyInterface } from './connection.js';
+export declare class Socket {
+    private _client;
+    private _data;
+    private _read;
+    private _promisedReading;
+    timeout: number;
+    _connectionClosed: boolean;
+    constructor(timeout: number);
+    connect(ip: string, port: number, proxy?: ProxyInterface): Promise<unknown>;
+    destroy(): Promise<boolean>;
+    recv(): void;
+    send(data: Buffer): Promise<void>;
+    read(length: number): Promise<Buffer<ArrayBufferLike>>;
+    reading(length: number): Promise<Buffer<ArrayBuffer> | undefined>;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}