@mtkruto/node 0.0.6

package/script/tl/3_tl_object_deserializer.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserialize = void 0;
+const deps_js_1 = require("../deps.js");
+const _1_tl_object_js_1 = require("./1_tl_object.js");
+const _2_types_js_1 = require("./2_types.js");
+function deserializeSingleParam(reader, type, ntype) {
+    if ((0, _1_tl_object_js_1.isTLObjectConstructor)(type)) {
+        const cid = reader.readInt32(false);
+        const constructor = _2_types_js_1.map.get(cid);
+        if (!constructor) {
+            throw new Error(`Constructor with ID ${cid} not found`);
+        }
+        return deserialize(reader, constructor[_1_tl_object_js_1.paramDesc], constructor);
+    }
+    if (type == Uint8Array) {
+        return reader.readBytes();
+    }
+    else {
+        switch (type) {
+            case "bigint":
+                if (ntype == "int128") {
+                    return reader.readInt128();
+                }
+                else if (ntype === "int256") {
+                    return reader.readInt256();
+                }
+                else {
+                    return reader.readInt64();
+                }
+            case "boolean":
+                return reader.readInt32(false) == 0x997275B5;
+            case "number":
+                return reader.readInt32();
+            case "string":
+                return reader.readString();
+            case "true":
+                return true;
+            default:
+                throw new Error(`Unexpected type ${type}`);
+        }
+    }
+}
+function deserialize(reader, paramDesc, constructor) {
+    const params = {};
+    const flagFields = {};
+    for (const [name, type, ntype] of paramDesc) {
+        if ((0, _1_tl_object_js_1.isOptionalParam)(ntype)) {
+            const { flagField, bitIndex } = (0, _1_tl_object_js_1.analyzeOptionalParam)(ntype);
+            const bits = flagFields[flagField];
+            if ((bits & (1 << bitIndex)) == 0) {
+                continue;
+            }
+        }
+        if (type == _1_tl_object_js_1.flags && ntype == "#") {
+            flagFields[name] = reader.readInt32();
+            continue;
+        }
+        if (type instanceof Array) {
+            (0, deps_js_1.assertEquals)(reader.readInt32(false), 0x1CB5C415);
+            const count = reader.readInt32();
+            const items = new Array();
+            for (let i = 0; i < count; i++) {
+                items.push(deserializeSingleParam(reader, type[0], ntype));
+            }
+            params[name] = items;
+            continue;
+        }
+        const value = deserializeSingleParam(reader, type, ntype);
+        if (value) {
+            params[name] = value;
+        }
+    }
+    return new constructor(params);
+}
+exports.deserialize = deserialize;

package/script/tl/3_tl_reader.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLReader = void 0;
+const _0_tl_raw_reader_js_1 = require("./0_tl_raw_reader.js");
+const _1_tl_object_js_1 = require("./1_tl_object.js");
+const _2_types_js_1 = require("./2_types.js");
+const _3_tl_object_deserializer_js_1 = require("./3_tl_object_deserializer.js");
+class TLReader extends _0_tl_raw_reader_js_1.TLRawReader {
+    readObject(id) {
+        if (!id) {
+            id = this.readInt32(false);
+        }
+        const constructor = _2_types_js_1.map.get(id);
+        if (constructor) {
+            return (0, _3_tl_object_deserializer_js_1.deserialize)(this, constructor[_1_tl_object_js_1.paramDesc], constructor);
+        }
+        throw new Error(`Unknown constructor ${id.toString(16)}`);
+    }
+}
+exports.TLReader = TLReader;

package/script/tl/3_tl_writer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLWriter = void 0;
+const _0_tl_raw_writer_js_1 = require("./0_tl_raw_writer.js");
+class TLWriter extends _0_tl_raw_writer_js_1.TLRawWriter {
+    writeObject(object) {
+        this.write(object.serialize());
+        return this;
+    }
+}
+exports.TLWriter = TLWriter;

package/script/tl/4_rpc_result.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCResult = void 0;
+const _1_tl_object_js_1 = require("./1_tl_object.js");
+const _3_tl_reader_js_1 = require("./3_tl_reader.js");
+class RPCResult {
+    static get [_1_tl_object_js_1.id]() {
+        return 0xF35C6D01;
+    }
+    constructor(messageId, result) {
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messageId
+        });
+        Object.defineProperty(this, "result", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: result
+        });
+    }
+    static deserialize(buffer) {
+        const reader = new _3_tl_reader_js_1.TLReader(buffer);
+        const messageId = reader.readInt64();
+        const result = reader.readObject();
+        return new RPCResult(messageId, result);
+    }
+}
+exports.RPCResult = RPCResult;

package/script/tl/5_message.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const _1_tl_object_js_1 = require("./1_tl_object.js");
+const _3_tl_reader_js_1 = require("./3_tl_reader.js");
+const _3_tl_writer_js_1 = require("./3_tl_writer.js");
+const _4_rpc_result_js_1 = require("./4_rpc_result.js");
+class Message {
+    constructor(id, seqNo, body) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: id
+        });
+        Object.defineProperty(this, "seqNo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: seqNo
+        });
+        Object.defineProperty(this, "body", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: body
+        });
+    }
+    serialize() {
+        if (this.body instanceof _4_rpc_result_js_1.RPCResult) {
+            throw new Error("Not applicable");
+        }
+        return new _3_tl_writer_js_1.TLWriter()
+            .writeInt64(this.id)
+            .writeInt32(this.seqNo)
+            .writeInt32(this.body[_1_tl_object_js_1.length])
+            .writeObject(this.body)
+            .buffer;
+    }
+    static deserialize(reader) {
+        const id_ = reader.readInt64();
+        const seqNo = reader.readInt32();
+        const length = reader.readInt32();
+        reader = new _3_tl_reader_js_1.TLReader(reader.read(length));
+        const cid = reader.readInt32(false);
+        let body;
+        {
+            if (cid == _4_rpc_result_js_1.RPCResult[_1_tl_object_js_1.id]) {
+                body = _4_rpc_result_js_1.RPCResult.deserialize(reader.buffer);
+            }
+            else {
+                body = reader.readObject(cid);
+            }
+        }
+        return new Message(id_, seqNo, body);
+    }
+}
+exports.Message = Message;

package/script/tl/6_message_container.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageContainer = void 0;
+const _1_tl_object_js_1 = require("./1_tl_object.js");
+const _3_tl_reader_js_1 = require("./3_tl_reader.js");
+const _3_tl_writer_js_1 = require("./3_tl_writer.js");
+const _5_message_js_1 = require("./5_message.js");
+class MessageContainer {
+    static get [_1_tl_object_js_1.id]() {
+        return 0x73F1F8DC;
+    }
+    constructor(messages) {
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messages
+        });
+    }
+    serialize() {
+        const writer = new _3_tl_writer_js_1.TLWriter();
+        writer.writeInt32(MessageContainer[_1_tl_object_js_1.id]);
+        writer.writeInt32(this.messages.length);
+        for (const message of this.messages) {
+            writer.write(message.serialize());
+        }
+        return writer.buffer;
+    }
+    static deserialize(buffer) {
+        const reader = new _3_tl_reader_js_1.TLReader(buffer);
+        const length = reader.readInt32();
+        const messages = new Array();
+        for (let i = 0; i < length; i++) {
+            messages.push(_5_message_js_1.Message.deserialize(reader));
+        }
+        return new MessageContainer(messages);
+    }
+}
+exports.MessageContainer = MessageContainer;

package/script/transport/transport.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+class Transport {
+    constructor() {
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "obfuscationParameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    encrypt(buffer) {
+        if (this.obfuscationParameters) {
+            return this.obfuscationParameters.encryptionCTR.encrypt(buffer);
+        }
+        else {
+            return buffer;
+        }
+    }
+    decrypt(buffer) {
+        if (this.obfuscationParameters) {
+            return this.obfuscationParameters.decryptionCTR.decrypt(buffer);
+        }
+        else {
+            return buffer;
+        }
+    }
+}
+exports.Transport = Transport;

package/script/transport/transport_intermediate.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportIntermediate = void 0;
+const _0_buffer_js_1 = require("../utilities/0_buffer.js");
+const _1_obfuscation_js_1 = require("../utilities/1_obfuscation.js");
+const transport_js_1 = require("./transport.js");
+class TransportIntermediate extends transport_js_1.Transport {
+    constructor(connection, obfuscated = false) {
+        super();
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: connection
+        });
+        Object.defineProperty(this, "obfuscated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: obfuscated
+        });
+    }
+    async initialize() {
+        if (!this.initialized) {
+            if (this.obfuscated) {
+                this.obfuscationParameters = await (0, _1_obfuscation_js_1.getObfuscationParameters)(0xEEEEEEEE, this.connection);
+            }
+            else {
+                await this.connection.write(new Uint8Array([0xEE, 0xEE, 0xEE, 0xEE]));
+            }
+            this.initialized = true;
+        }
+        else {
+            throw new Error("Transport already initialized");
+        }
+    }
+    async receive() {
+        let length;
+        {
+            const buffer = new Uint8Array(4);
+            await this.connection.read(buffer);
+            const dataView = new DataView(this.decrypt(buffer).buffer);
+            length = dataView.getUint32(0, true);
+        }
+        const buffer = new Uint8Array(length);
+        await this.connection.read(buffer);
+        return this.decrypt(buffer);
+    }
+    async send(buffer) {
+        if (!this.initialized) {
+            throw new Error("Transport not initialized");
+        }
+        const length = (0, _0_buffer_js_1.bufferFromBigInt)(buffer.length, 4);
+        await this.connection.write(this.encrypt((0, _0_buffer_js_1.concat)(length, buffer)));
+    }
+    deinitialize() {
+        this.initialized = false;
+    }
+}
+exports.TransportIntermediate = TransportIntermediate;

package/script/transport/transport_provider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTransportProvider = exports.defaultDc = void 0;
+const connection_web_socket_js_1 = require("../connection/connection_web_socket.js");
+const transport_intermediate_js_1 = require("./transport_intermediate.js");
+exports.defaultDc = "2-test";
+const dcToNameMap = {
+    "1": "pluto",
+    "1-test": "pluto",
+    "2": "venus",
+    "2-test": "venus",
+    "3": "aurora",
+    "3-test": "aurora",
+    "4": "vesta",
+    "5": "flora",
+};
+const defaultTransportProvider = (params) => {
+    return (cdn) => {
+        const { dc, wss = typeof location !== "undefined" && location.protocol == "http:" ? false : true } = params ?? { dc: exports.defaultDc };
+        const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.telegram.org/apiws${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
+        const connection = new connection_web_socket_js_1.ConnectionWebSocket(url);
+        const transport = new transport_intermediate_js_1.TransportIntermediate(connection, true);
+        const dcId = Number(dc[0]) + (dc.endsWith("-test") ? 10000 : 0) * (cdn ? -1 : 1);
+        return { connection, transport, dcId };
+    };
+};
+exports.defaultTransportProvider = defaultTransportProvider;

package/script/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/utilities/0_bigint.js

@@ -0,0 +1,67 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomBigInt = exports.bigIntFromBuffer = exports.mod = exports.modExp = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+function modExp(a, b, n) {
+    a %= n;
+    let result = 1n;
+    let x = a;
+    while (b > 0n) {
+        const leastSignificantBit = b % 2n;
+        b /= 2n;
+        if (leastSignificantBit == 1n) {
+            result *= x;
+            result %= n;
+        }
+        x *= x;
+        x %= n;
+    }
+    return result;
+}
+exports.modExp = modExp;
+function mod(n, m) {
+    return ((n % m) + m) % m;
+}
+exports.mod = mod;
+function bigIntFromBuffer(buffer, little = true, signed = false) {
+    let randomBuffer = buffer;
+    const bytesLength = randomBuffer.length;
+    if (little) {
+        randomBuffer = randomBuffer.reverse();
+    }
+    let bigIntVar = BigInt("0x" + [...randomBuffer].map((v) => v.toString(16).padStart(2, "0")).join(""));
+    if (signed && Math.floor(bigIntVar.toString(2).length / 8) >= bytesLength) {
+        bigIntVar = bigIntVar - (2n ** (BigInt(bytesLength * 8)));
+    }
+    return bigIntVar;
+}
+exports.bigIntFromBuffer = bigIntFromBuffer;
+function getRandomBigInt(byteLength, little, signed) {
+    const randomBytes = new Uint8Array(byteLength);
+    dntShim.crypto.getRandomValues(randomBytes);
+    return bigIntFromBuffer(randomBytes, little, signed);
+}
+exports.getRandomBigInt = getRandomBigInt;

package/script/utilities/0_buffer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferFromBigInt = exports.concat = void 0;
+function concat(...buffers) {
+    return new Uint8Array(buffers.map((v) => Array.from(v)).flat());
+}
+exports.concat = concat;
+const bufferFromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+function bufferFromBigInt(bigIntVar, bytesNumber, little = true, signed = false) {
+    bigIntVar = BigInt(typeof bigIntVar === "number" ? Math.ceil(bigIntVar) : bigIntVar);
+    const bitLength = bigIntVar.toString(2).length;
+    const bytes = Math.ceil(bitLength / 8);
+    if (bytesNumber < bytes) {
+        throw new Error("OverflowError: int too big to convert");
+    }
+    if (!signed && bigIntVar < 0n) {
+        throw new Error("Cannot convert to unsigned");
+    }
+    let below = false;
+    if (bigIntVar < 0n) {
+        below = true;
+        bigIntVar = bigIntVar < 0 ? bigIntVar * -1n : bigIntVar;
+    }
+    const hex = bigIntVar.toString(16).padStart(bytesNumber * 2, "0");
+    const buffer = bufferFromHexString(hex);
+    if (signed && below) {
+        buffer[buffer.length - 1] = 256 -
+            buffer[buffer.length - 1];
+        for (let i = 0; i < buffer.length - 1; i++) {
+            buffer[i] = 255 - buffer[i];
+        }
+    }
+    if (little) {
+        buffer.reverse();
+    }
+    return buffer;
+}
+exports.bufferFromBigInt = bufferFromBigInt;

package/script/utilities/0_crypto.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTR = void 0;
+const deps_js_1 = require("../deps.js");
+class CTR {
+    constructor(key, iv) {
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: key
+        });
+        Object.defineProperty(this, "iv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: iv
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Uint8Array(1)
+        });
+    }
+    encrypt(data) {
+        const [encrypted, iv, state] = (0, deps_js_1.ctr256Encrypt)(data, this.key, this.iv, this.state);
+        this.iv = iv;
+        this.state = state;
+        return new Uint8Array(encrypted);
+    }
+    decrypt(data) {
+        const [decrypted, iv, state] = (0, deps_js_1.ctr256Decrypt)(data, this.key, this.iv, this.state);
+        this.iv = iv;
+        this.state = state;
+        return new Uint8Array(decrypted);
+    }
+}
+exports.CTR = CTR;

package/script/utilities/0_hash.js

@@ -0,0 +1,35 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha1 = exports.sha256 = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+async function sha256(payload) {
+    return new Uint8Array(await dntShim.crypto.subtle.digest("SHA-256", payload));
+}
+exports.sha256 = sha256;
+async function sha1(payload) {
+    return new Uint8Array(await dntShim.crypto.subtle.digest("SHA-1", payload));
+}
+exports.sha1 = sha1;

package/script/utilities/1_auth.js

@@ -0,0 +1,56 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rsaPad = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const deps_js_1 = require("../deps.js");
+const _0_bigint_js_1 = require("./0_bigint.js");
+const _0_buffer_js_1 = require("./0_buffer.js");
+const _0_hash_js_1 = require("./0_hash.js");
+async function rsaPad(data, [serverKey, exponent]) {
+    (0, deps_js_1.assert)(data.length <= 144);
+    let keyAesEncryptedInt;
+    let tries = 0;
+    do {
+        if (++tries == 10) {
+            throw new Error("Out of tries");
+        }
+        const dataWithPadding = (0, _0_buffer_js_1.concat)(data, new Uint8Array(192 - data.length));
+        const dataPadReversed = new Uint8Array(dataWithPadding).reverse();
+        const tempKey = dntShim.crypto.getRandomValues(new Uint8Array(32));
+        const dataWithHash = (0, _0_buffer_js_1.concat)(dataPadReversed, await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(tempKey, dataWithPadding)));
+        const aesEncrypted = (0, deps_js_1.ige256Encrypt)(dataWithHash, tempKey, new Uint8Array(32));
+        const aesEncryptedSha256 = await (0, _0_hash_js_1.sha256)(aesEncrypted);
+        const tempKeyXor = tempKey.map((v, i) => v ^ aesEncryptedSha256[i]);
+        const keyAesEncrypted = (0, _0_buffer_js_1.concat)(tempKeyXor, aesEncrypted);
+        (0, deps_js_1.assertEquals)(keyAesEncrypted.length, 256);
+        keyAesEncryptedInt = (0, _0_bigint_js_1.bigIntFromBuffer)(keyAesEncrypted, false, false);
+    } while (keyAesEncryptedInt >= serverKey);
+    const encryptedDataInt = (0, _0_bigint_js_1.modExp)(keyAesEncryptedInt, exponent, serverKey);
+    const encryptedData = (0, _0_buffer_js_1.bufferFromBigInt)(encryptedDataInt, 256, false, false);
+    (0, deps_js_1.assertEquals)(encryptedData.length, 256);
+    return encryptedData;
+}
+exports.rsaPad = rsaPad;