teleproto 203.0.0

package/sessions/StringSession.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringSession = void 0;
+const Memory_1 = require("./Memory");
+const extensions_1 = require("../extensions");
+const AuthKey_1 = require("../crypto/AuthKey");
+const CURRENT_VERSION = "1";
+class StringSession extends Memory_1.MemorySession {
+    /**
+     * This session file can be easily saved and loaded as a string. According
+     * to the initial design, it contains only the data that is necessary for
+     * successful connection and authentication, so takeout ID is not stored.
+
+     * It is thought to be used where you don't want to create any on-disk
+     * files but would still like to be able to save and load existing sessions
+     * by other means.
+
+     * You can use custom `encode` and `decode` functions, if present:
+
+     * `encode` definition must be ``function encode(value: Buffer) -> string:``.
+     * `decode` definition must be ``function decode(value: string) -> Buffer:``.
+     * @param session {string|null}
+     */
+    constructor(session) {
+        super();
+        if (session) {
+            if (session[0] !== CURRENT_VERSION) {
+                throw new Error("Not a valid string");
+            }
+            session = session.slice(1);
+            const r = StringSession.decode(session);
+            const reader = new extensions_1.BinaryReader(r);
+            this._dcId = reader.read(1).readUInt8(0);
+            if (session.length == 352) {
+                // Telethon session
+                const ip_v4 = reader.read(4);
+                // TODO looks ugly smh
+                this._serverAddress =
+                    ip_v4[0].toString() +
+                        "." +
+                        ip_v4[1].toString() +
+                        "." +
+                        ip_v4[2].toString() +
+                        "." +
+                        ip_v4[3].toString();
+            }
+            else {
+                // TODO find a better of doing this
+                const serverAddressLen = reader.read(2).readInt16BE(0);
+                if (serverAddressLen > 100) {
+                    reader.offset -= 2;
+                    this._serverAddress = reader
+                        .read(16)
+                        .toString("hex")
+                        .match(/.{1,4}/g)
+                        .map((val) => val.replace(/^0+/, ""))
+                        .join(":")
+                        .replace(/0000\:/g, ":")
+                        .replace(/:{2,}/g, "::");
+                }
+                else {
+                    this._serverAddress = reader
+                        .read(serverAddressLen)
+                        .toString();
+                }
+            }
+            this._port = reader.read(2).readInt16BE(0);
+            this._key = reader.read(-1);
+        }
+    }
+    /**
+     * @param x {Buffer}
+     * @returns {string}
+     */
+    static encode(x) {
+        return x.toString("base64");
+    }
+    /**
+     * @param x {string}
+     * @returns {Buffer}
+     */
+    static decode(x) {
+        return Buffer.from(x, "base64");
+    }
+    async load() {
+        if (this._key) {
+            this._authKey = new AuthKey_1.AuthKey();
+            await this._authKey.setKey(this._key);
+        }
+    }
+    save() {
+        if (!this.authKey || !this.serverAddress || !this.port) {
+            return "";
+        }
+        // TS is weird
+        const key = this.authKey.getKey();
+        if (!key) {
+            return "";
+        }
+        const dcBuffer = Buffer.from([this.dcId]);
+        const addressBuffer = Buffer.from(this.serverAddress);
+        const addressLengthBuffer = Buffer.alloc(2);
+        addressLengthBuffer.writeInt16BE(addressBuffer.length, 0);
+        const portBuffer = Buffer.alloc(2);
+        portBuffer.writeInt16BE(this.port, 0);
+        return (CURRENT_VERSION +
+            StringSession.encode(Buffer.concat([
+                dcBuffer,
+                addressLengthBuffer,
+                addressBuffer,
+                portBuffer,
+                key,
+            ])));
+    }
+}
+exports.StringSession = StringSession;

package/sessions/index.d.ts

@@ -0,0 +1,4 @@
+export { MemorySession } from "./Memory";
+export { StringSession } from "./StringSession";
+export { StoreSession } from "./StoreSession";
+export { Session } from "./Abstract";

package/sessions/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = exports.StoreSession = exports.StringSession = exports.MemorySession = void 0;
+var Memory_1 = require("./Memory");
+Object.defineProperty(exports, "MemorySession", { enumerable: true, get: function () { return Memory_1.MemorySession; } });
+var StringSession_1 = require("./StringSession");
+Object.defineProperty(exports, "StringSession", { enumerable: true, get: function () { return StringSession_1.StringSession; } });
+var StoreSession_1 = require("./StoreSession");
+Object.defineProperty(exports, "StoreSession", { enumerable: true, get: function () { return StoreSession_1.StoreSession; } });
+var Abstract_1 = require("./Abstract");
+Object.defineProperty(exports, "Session", { enumerable: true, get: function () { return Abstract_1.Session; } });
+// @ts-ignore
+//export {CacheApiSession} from './CacheApiSession';

package/sessions/localStorage.d.ts

@@ -0,0 +1 @@
+export declare const LocalStorage: any;

package/sessions/localStorage.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+exports.LocalStorage = require("node-localstorage").LocalStorage;

package/tl/AllTLObjects.d.ts

@@ -0,0 +1,3 @@
+export declare const LAYER = 203;
+declare const tlobjects: any;
+export { tlobjects };

package/tl/AllTLObjects.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tlobjects = exports.LAYER = void 0;
+exports.LAYER = 203;
+const _1 = require(".");
+const tlobjects = {};
+exports.tlobjects = tlobjects;
+for (const tl of Object.values(_1.Api)) {
+    if ("CONSTRUCTOR_ID" in tl) {
+        tlobjects[tl.CONSTRUCTOR_ID] = tl;
+    }
+    else {
+        for (const sub of Object.values(tl)) {
+            tlobjects[sub.CONSTRUCTOR_ID] = sub;
+        }
+    }
+}

package/tl/MTProtoRequest.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+export declare class MTProtoRequest {
+    private sent;
+    private sequence;
+    private msgId;
+    private readonly dirty;
+    private sendTime;
+    private confirmReceived;
+    private constructorId;
+    private readonly confirmed;
+    private responded;
+    constructor();
+    onSendSuccess(): void;
+    onConfirm(): void;
+    needResend(): boolean;
+    onSend(): void;
+    onResponse(buffer: Buffer): void;
+    onException(exception: Error): void;
+}

package/tl/MTProtoRequest.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MTProtoRequest = void 0;
+class MTProtoRequest {
+    constructor() {
+        this.sent = false;
+        this.msgId = 0; // long
+        this.sequence = 0;
+        this.dirty = false;
+        this.sendTime = 0;
+        this.confirmReceived = false;
+        // These should be overrode
+        this.constructorId = 0;
+        this.confirmed = false;
+        this.responded = false;
+    }
+    // these should not be overrode
+    onSendSuccess() {
+        this.sendTime = new Date().getTime();
+        this.sent = true;
+    }
+    onConfirm() {
+        this.confirmReceived = true;
+    }
+    needResend() {
+        return (this.dirty ||
+            (this.confirmed &&
+                !this.confirmReceived &&
+                new Date().getTime() - this.sendTime > 3000));
+    }
+    // These should be overrode
+    onSend() {
+        throw Error("Not overload " + this.constructor.name);
+    }
+    onResponse(buffer) { }
+    onException(exception) { }
+}
+exports.MTProtoRequest = MTProtoRequest;