teleproto 1.214.0

package/tl/patched/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchAll = patchAll;
+const api_1 = require("../api");
+const message_1 = require("../custom/message");
+function getGetter(obj, prop) {
+    while (obj) {
+        let getter = Object.getOwnPropertyDescriptor(obj, prop);
+        if (getter && getter.get) {
+            return getter.get;
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+}
+function getSetter(obj, prop) {
+    while (obj) {
+        let getter = Object.getOwnPropertyDescriptor(obj, prop);
+        if (getter && getter.set) {
+            return getter.set;
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+}
+const getInstanceMethods = (obj) => {
+    let keys = {
+        methods: new Set(),
+        setters: new Set(),
+        getters: new Set(),
+    };
+    let topObject = obj;
+    const mapAllMethods = (property) => {
+        const getter = getGetter(topObject, property);
+        const setter = getSetter(topObject, property);
+        if (getter) {
+            keys["getters"].add(property);
+        }
+        else if (setter) {
+            keys["setters"].add(property);
+        }
+        else {
+            if (!(property == "constructor")) {
+                keys["methods"].add(property);
+            }
+        }
+    };
+    do {
+        Object.getOwnPropertyNames(obj).map(mapAllMethods);
+        // walk-up the prototype chain
+        obj = Object.getPrototypeOf(obj);
+    } while (
+    // not the the Object prototype methods (hasOwnProperty, etc...)
+    obj &&
+        Object.getPrototypeOf(obj));
+    return keys;
+};
+function patchClass(clazz) {
+    const { getters, setters, methods } = getInstanceMethods(message_1.CustomMessage.prototype);
+    for (const getter of getters) {
+        Object.defineProperty(clazz.prototype, getter, {
+            get: getGetter(message_1.CustomMessage.prototype, getter),
+        });
+    }
+    for (const setter of setters) {
+        Object.defineProperty(clazz.prototype, setter, {
+            set: getSetter(message_1.CustomMessage.prototype, setter),
+        });
+    }
+    for (const method of methods) {
+        clazz.prototype[method] = message_1.CustomMessage.prototype[method];
+    }
+}
+function patchAll() {
+    patchClass(api_1.Api.Message);
+    patchClass(api_1.Api.MessageService);
+    patchClass(api_1.Api.MessageEmpty);
+}

package/tl/schemaTl.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: string;
+export = _exports;

package/tl/schemaTl.js

@@ -0,0 +1,64 @@
+"use strict";
+module.exports = `
+resPQ#05162463 nonce:int128 server_nonce:int128 pq:string server_public_key_fingerprints:Vector<long> = ResPQ;
+p_q_inner_data#83c95aec pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 = P_Q_inner_data;
+p_q_inner_data_dc#a9f55f95 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 dc:int = P_Q_inner_data;
+p_q_inner_data_temp#3c6a84d4 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 expires_in:int = P_Q_inner_data;
+p_q_inner_data_temp_dc#56fddf88 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 dc:int expires_in:int = P_Q_inner_data;
+bind_auth_key_inner#75a3f765 nonce:long temp_auth_key_id:long perm_auth_key_id:long temp_session_id:long expires_at:int = BindAuthKeyInner;
+server_DH_params_fail#79cb045d nonce:int128 server_nonce:int128 new_nonce_hash:int128 = Server_DH_Params;
+server_DH_params_ok#d0e8075c nonce:int128 server_nonce:int128 encrypted_answer:string = Server_DH_Params;
+server_DH_inner_data#b5890dba nonce:int128 server_nonce:int128 g:int dh_prime:string g_a:string server_time:int = Server_DH_inner_data;
+client_DH_inner_data#6643b654 nonce:int128 server_nonce:int128 retry_id:long g_b:string = Client_DH_Inner_Data;
+dh_gen_ok#3bcbf734 nonce:int128 server_nonce:int128 new_nonce_hash1:int128 = Set_client_DH_params_answer;
+dh_gen_retry#46dc1fb9 nonce:int128 server_nonce:int128 new_nonce_hash2:int128 = Set_client_DH_params_answer;
+dh_gen_fail#a69dae02 nonce:int128 server_nonce:int128 new_nonce_hash3:int128 = Set_client_DH_params_answer;
+destroy_auth_key_ok#f660e1d4 = DestroyAuthKeyRes;
+destroy_auth_key_none#0a9f2259 = DestroyAuthKeyRes;
+destroy_auth_key_fail#ea109b13 = DestroyAuthKeyRes;
+---functions---
+req_pq#60469778 nonce:int128 = ResPQ;
+req_pq_multi#be7e8ef1 nonce:int128 = ResPQ;
+req_DH_params#d712e4be nonce:int128 server_nonce:int128 p:string q:string public_key_fingerprint:long encrypted_data:string = Server_DH_Params;
+set_client_DH_params#f5045f1f nonce:int128 server_nonce:int128 encrypted_data:string = Set_client_DH_params_answer;
+destroy_auth_key#d1435160 = DestroyAuthKeyRes;
+---types---
+msgs_ack#62d6b459 msg_ids:Vector<long> = MsgsAck;
+bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int error_code:int = BadMsgNotification;
+bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long = BadMsgNotification;
+msgs_state_req#da69fb52 msg_ids:Vector<long> = MsgsStateReq;
+msgs_state_info#04deb57d req_msg_id:long info:string = MsgsStateInfo;
+msgs_all_info#8cc0d131 msg_ids:Vector<long> info:string = MsgsAllInfo;
+msg_detailed_info#276d3ec6 msg_id:long answer_msg_id:long bytes:int status:int = MsgDetailedInfo;
+msg_new_detailed_info#809db6df answer_msg_id:long bytes:int status:int = MsgDetailedInfo;
+msg_resend_req#7d861a08 msg_ids:Vector<long> = MsgResendReq;
+rpc_error#2144ca19 error_code:int error_message:string = RpcError;
+rpc_answer_unknown#5e2ad36e = RpcDropAnswer;
+rpc_answer_dropped_running#cd78e586 = RpcDropAnswer;
+rpc_answer_dropped#a43ad8b7 msg_id:long seq_no:int bytes:int = RpcDropAnswer;
+future_salt#0949d9dc valid_since:int valid_until:int salt:long = FutureSalt;
+future_salts#ae500895 req_msg_id:long now:int salts:vector<future_salt> = FutureSalts;
+pong#347773c5 msg_id:long ping_id:long = Pong;
+destroy_session_ok#e22045fc session_id:long = DestroySessionRes;
+destroy_session_none#62d350c9 session_id:long = DestroySessionRes;
+new_session_created#9ec20908 first_msg_id:long unique_id:long server_salt:long = NewSession;
+http_wait#9299359f max_delay:int wait_after:int max_wait:int = HttpWait;
+ipPort#d433ad73 ipv4:int port:int = IpPort;
+ipPortSecret#37982646 ipv4:int port:int secret:bytes = IpPort;
+accessPointRule#4679b65f phone_prefix_rules:string dc_id:int ips:vector<IpPort> = AccessPointRule;
+help.configSimple#5a592a6c date:int expires:int rules:vector<AccessPointRule> = help.ConfigSimple;
+tlsClientHello blocks:vector<TlsBlock> = TlsClientHello;
+tlsBlockString data:string = TlsBlock;
+tlsBlockRandom length:int = TlsBlock;
+tlsBlockZero length:int = TlsBlock;
+tlsBlockDomain = TlsBlock;
+tlsBlockGrease seed:int = TlsBlock;
+tlsBlockPublicKey = TlsBlock;
+tlsBlockScope entries:Vector<TlsBlock> = TlsBlock;
+---functions---
+rpc_drop_answer#58e4a740 req_msg_id:long = RpcDropAnswer;
+get_future_salts#b921bd04 num:int = FutureSalts;
+ping#7abe77ec ping_id:long = Pong;
+ping_delay_disconnect#f3427b8c ping_id:long disconnect_delay:int = Pong;
+destroy_session#e7512126 session_id:long = DestroySessionRes;
+`;

package/tl/types-generator/generate.d.ts

@@ -0,0 +1 @@
+export {};

package/tl/types-generator/generate.js

@@ -0,0 +1,84 @@
+"use strict";
+const path = require("path");
+const fs = require("fs");
+const { parseTl } = require("../generationHelpers");
+const templateFn = require("./template");
+const INPUT_FILE = path.resolve(__dirname, "../static/api.tl");
+const SCHEMA_FILE = path.resolve(__dirname, "../static/schema.tl");
+const OUTPUT_FILE = path.resolve(__dirname, "../api.d.ts");
+const peersToPatch = [
+    "InputPeer",
+    "Peer",
+    "InputUser",
+    "User",
+    "UserFull",
+    "Chat",
+    "ChatFull",
+    "InputChannel",
+];
+function patchMethods(methods) {
+    for (const method of methods) {
+        for (const arg in method["argsConfig"]) {
+            if (peersToPatch.includes(method["argsConfig"][arg]["type"])) {
+                method["argsConfig"][arg]["type"] = "EntityLike";
+            }
+            else if (method["argsConfig"][arg]["type"] &&
+                arg.toLowerCase().includes("msgid")) {
+                if (method["argsConfig"][arg]["type"] !== "long") {
+                    method["argsConfig"][arg]["type"] = "MessageIDLike";
+                }
+            }
+        }
+    }
+}
+function main() {
+    const tlContent = fs.readFileSync(INPUT_FILE, "utf-8");
+    const apiConfig = extractParams(tlContent);
+    const schemeContent = fs.readFileSync(SCHEMA_FILE, "utf-8");
+    const schemeConfig = extractParams(schemeContent);
+    const types = [...apiConfig.types, ...schemeConfig.types];
+    const functions = [...apiConfig.functions, ...schemeConfig.functions];
+    const constructors = [
+        ...apiConfig.constructors,
+        ...schemeConfig.constructors,
+    ];
+    // patching custom types
+    patchMethods(functions);
+    const generated = templateFn({
+        types: types,
+        functions: functions,
+        constructors: constructors,
+    });
+    fs.writeFileSync(OUTPUT_FILE, generated);
+}
+function extractParams(fileContent) {
+    const defInterator = parseTl(fileContent, 109);
+    const types = {};
+    const constructors = [];
+    const functions = [];
+    for (const def of defInterator) {
+        if (def.isFunction) {
+            functions.push(def);
+        }
+        else {
+            if (!types[def.result]) {
+                const [namespace, name] = def.result.includes(".")
+                    ? def.result.split(".")
+                    : [undefined, def.result];
+                types[def.result] = {
+                    namespace,
+                    name,
+                    constructors: [],
+                };
+            }
+            types[def.result].constructors.push(def.namespace ? `${def.namespace}.${def.name}` : def.name);
+            constructors.push(def);
+        }
+    }
+    return {
+        types: Object.values(types),
+        constructors,
+        functions,
+    };
+}
+main();

package/tl/types-generator/template.d.ts

@@ -0,0 +1,6 @@
+declare function _exports({ types, constructors, functions }: {
+    types: any;
+    constructors: any;
+    functions: any;
+}): string;
+export = _exports;

package/tl/types-generator/template.js

@@ -0,0 +1,257 @@
+"use strict";
+// Not sure what they are for.
+const WEIRD_TYPES = new Set(["Bool", "X", "Type"]);
+module.exports = ({ types, constructors, functions }) => {
+    function groupByKey(collection, key) {
+        return collection.reduce((byKey, member) => {
+            const keyValue = member[key] || "_";
+            if (!byKey[keyValue]) {
+                byKey[keyValue] = [member];
+            }
+            else {
+                byKey[keyValue].push(member);
+            }
+            return byKey;
+        }, {});
+    }
+    function getClassNameWithNameSpace(name, namespace) {
+        return namespace
+            ? namespace.toLowerCase() + "." + upperFirst(name)
+            : upperFirst(name);
+    }
+    function renderTypes(types, indent) {
+        return types
+            .map(({ name, constructors }) => `
+      ${!constructors.length ? "// " : ""}export type Type${upperFirst(name)} = ${constructors.map((name) => name).join(" | ")};
+    `.trim())
+            .join(`\n${indent}`);
+    }
+    function renderConstructors(constructors, indent) {
+        return constructors
+            .map((args) => {
+            // console.log(args);
+            const { name, namespace, argsConfig, constructorId, subclassOfId, } = args;
+            if (name === "Message") {
+                return `export class Message extends CustomMessage {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "request";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+    }`;
+            }
+            else if (name === "MessageService") {
+                return `export class MessageService extends CustomMessage {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "request";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+    }`;
+            }
+            const argKeys = Object.keys(argsConfig);
+            // console.log(constructorId);
+            if (!argKeys.length) {
+                return `export class ${upperFirst(name)} extends VirtualClass<void> {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "constructor";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+}`;
+            }
+            const hasRequiredArgs = argKeys.some((argName) => !argsConfig[argName].flagIndicator &&
+                !argsConfig[argName].isFlag);
+            return `
+      export class ${upperFirst(name)} extends VirtualClass<{
+${indent}  ${Object.keys(argsConfig)
+                .map((argName) => `
+        ${renderArg(argName, argsConfig[argName])};
+      `.trim())
+                .join(`\n${indent}  `)}
+${indent}}${!hasRequiredArgs ? "" : ""}> {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "constructor";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+${indent}  ${Object.keys(argsConfig)
+                .map((argName) => `
+        ${renderArg(argName, argsConfig[argName])};
+      `.trim())
+                .join(`\n${indent}  `)}
+${indent}}`.trim();
+        })
+            .join(`\n${indent}`);
+    }
+    function renderRequests(requests, indent) {
+        return requests
+            .map((args) => {
+            const { name, argsConfig, result, constructorId, namespace, subclassOfId, } = args;
+            const argKeys = Object.keys(argsConfig);
+            if (!argKeys.length) {
+                return `export class ${upperFirst(name)} extends Request<void, ${renderResult(result)}> {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "request";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+}`;
+            }
+            const hasRequiredArgs = argKeys.some((argName) => !argsConfig[argName].flagIndicator &&
+                !argsConfig[argName].isFlag);
+            return `
+      export class ${upperFirst(name)} extends Request<Partial<{
+${indent}  ${argKeys
+                .map((argName) => `
+        ${renderArg(argName, argsConfig[argName])};
+      `.trim())
+                .join(`\n${indent}  `)}
+${indent}}${!hasRequiredArgs ? "" : ""}>, ${renderResult(result)}> {
+${indent}CONSTRUCTOR_ID: ${constructorId};
+${indent}SUBCLASS_OF_ID: ${subclassOfId};
+${indent}classType: "request";
+${indent}className: "${getClassNameWithNameSpace(name, namespace)}";
+${indent}static fromReader(reader: Reader): ${upperFirst(name)};
+${indent}  ${argKeys
+                .map((argName) => `
+
+        ${renderArg(argName, argsConfig[argName])};
+      `.trim())
+                .join(`\n${indent}  `)}
+${indent}}`.trim();
+        })
+            .join(`\n${indent}`);
+    }
+    function renderResult(result) {
+        const vectorMatch = result.match(/[Vv]ector<([\w\d.]+)>/);
+        const isVector = Boolean(vectorMatch);
+        const scalarValue = isVector ? vectorMatch[1] : result;
+        const isTlType = Boolean(scalarValue.match(/^[A-Z]/)) || scalarValue.includes(".");
+        return renderValueType(scalarValue, isVector, isTlType);
+    }
+    function renderArg(argName, argConfig) {
+        const { isVector, isFlag, skipConstructorId, flagIndicator, type } = argConfig;
+        const valueType = renderValueType(type, isVector, !skipConstructorId);
+        return `${flagIndicator ? "// " : ""}${argName}${isFlag || (argName === "randomId" && type === "long" && !isVector)
+            ? "?"
+            : ""}: ${valueType}`;
+    }
+    function renderValueType(type, isVector, isTlType) {
+        if (WEIRD_TYPES.has(type)) {
+            return isVector ? `${type}[]` : type;
+        }
+        let resType;
+        if (typeof type === "string" && isTlType) {
+            resType = renderTypeName(type);
+        }
+        else {
+            resType = type;
+        }
+        if (resType === "true") {
+            resType = "boolean";
+        }
+        if (isVector) {
+            resType = `${resType}[]`;
+        }
+        return resType;
+    }
+    function renderTypeName(typeName) {
+        return typeName.includes(".")
+            ? typeName.replace(".", ".Type")
+            : `Api.Type${typeName}`;
+    }
+    function upperFirst(str) {
+        return `${str[0].toUpperCase()}${str.slice(1)}`;
+    }
+    function lowerFirst(str) {
+        return `${str[0].toLowerCase()}${str.slice(1)}`;
+    }
+    const typesByNs = groupByKey(types, "namespace");
+    const constructorsByNs = groupByKey(constructors, "namespace");
+    const requestsByNs = groupByKey(functions, "namespace");
+    // language=TypeScript
+    return `
+// This file is autogenerated. All changes will be overwritten.
+import { BigInteger } from 'big-integer';
+import {EntityLike,MessageIDLike} from "../define";
+import { CustomMessage } from "./custom/message";
+
+
+export namespace Api {
+  type AnyLiteral = Record<string, any> | void;
+  type Reader = any; // To be defined.
+  type Client = any; // To be defined.
+  type Utils = any; // To be defined.
+  type X = unknown;
+  type Type = unknown;
+  type Bool = boolean;
+  type int = number;
+  type double = number;
+  type float = number;
+  type int128 = BigInteger;
+  type int256 = BigInteger;
+  type long = BigInteger;
+  type bytes = Buffer;
+  class VirtualClass<Args extends AnyLiteral> {
+    static CONSTRUCTOR_ID: number;
+    static SUBCLASS_OF_ID: number;
+    static className: string;
+    static classType: 'constructor' | 'request';
+    static serializeBytes(data: Buffer | string): Buffer;
+    static serializeDate(date: Date | number): Buffer;
+    getBytes():Buffer;
+    CONSTRUCTOR_ID: number;
+    SUBCLASS_OF_ID: number;
+    className: string;
+    classType: 'constructor' | 'request';
+    constructor(args: Args);
+    originalArgs: Args;
+    toJSON(): Args;
+  }
+  class Request<Args, Response> extends VirtualClass<Partial<Args>> {
+    static readResult(reader: Reader): Buffer;
+    resolve(client: Client, utils: Utils): Promise<void>;
+    __response: Response;
+  }
+  ${renderConstructors(constructorsByNs._, "  ")}
+  ${renderRequests(requestsByNs._, "  ")}
+// namespaces
+  ${Object.keys(constructorsByNs)
+        .map((namespace) => namespace !== "_"
+        ? `
+  export namespace ${namespace} {
+    ${renderConstructors(constructorsByNs[namespace], "    ")}
+  }`
+        : "")
+        .join("\n")}
+  ${Object.keys(typesByNs)
+        .map((namespace) => namespace !== "_"
+        ? `
+  export namespace ${namespace} {
+    ${renderTypes(typesByNs[namespace], "    ")}
+  }`
+        : "")
+        .join("\n")}
+  ${Object.keys(requestsByNs)
+        .map((namespace) => namespace !== "_"
+        ? `
+  export namespace ${namespace} {
+    ${renderRequests(requestsByNs[namespace], "    ")}
+  }`
+        : "")
+        .join("\n")}
+// Types
+  export type TypeEntityLike = EntityLike;
+  ${renderTypes(typesByNs._, "  ")}
+// All requests
+  export type AnyRequest = ${requestsByNs._.map(({ name }) => upperFirst(name)).join(" | ")}
+    | ${Object.keys(requestsByNs)
+        .filter((ns) => ns !== "_")
+        .map((ns) => requestsByNs[ns]
+        .map(({ name }) => `${ns}.${upperFirst(name)}`)
+        .join(" | "))
+        .join("\n    | ")};
+}
+`;
+};