@mtkruto/node 0.0.63 → 0.0.72

package/esm/client/client.js

@@ -2,28 +2,29 @@ import { gunzip } from "../deps.js";
 import { ackThreshold } from "../constants.js";
 import { getRandomBigInt } from "../utilities/0_bigint.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
-import { BadMsgNotification, BadServerSalt, GZIPPacked, MsgsAck, Pong, RPCError, Updates } from "../tl/2_types.js";
-import { Ping } from "../tl/3_functions.js";
+import * as types from "../tl/2_types.js";
+import * as functions from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
 import { RPCResult } from "../tl/4_rpc_result.js";
 import { Message } from "../tl/5_message.js";
 import { MessageContainer } from "../tl/6_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
+import { SessionMemory } from "../session/session_memory.js";
 export class Client extends ClientAbstract {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "sessionId", {
+    constructor(session = new SessionMemory(), params) {
+        super(params?.transportProvider);
+        Object.defineProperty(this, "session", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: getRandomBigInt(8, true, false)
+            value: session
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "sessionId", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: getRandomBigInt(8, true, false)
         });
         Object.defineProperty(this, "state", {
             enumerable: true,
@@ -51,30 +52,39 @@ export class Client extends ClientAbstract {
         });
     }
     async connect() {
-        const plain = new ClientPlain(this.transportProvider);
-        await plain.connect();
-        const { authKey: key, authKeyId: id, salt } = await plain.createAuthKey();
-        await plain.disconnect();
-        this.auth = { key, id };
-        this.state.salt = salt;
+        await this.session.load();
+        if (this.session.authKey == null) {
+            const plain = new ClientPlain(this.transportProvider);
+            await plain.connect();
+            const { authKey, salt } = await plain.createAuthKey();
+            await plain.disconnect();
+            this.state.salt = salt;
+            this.session.authKey = authKey;
+        }
+        if (this.session.dc != null) {
+            const { connection, transport, dcId } = this.transportProvider({ dc: this.session.dc, cdn: false });
+            this.connection = connection;
+            this.transport = transport;
+            this.dcId = dcId;
+        }
         await super.connect();
         // logger().debug("Client connected");
         this.receiveLoop();
         this.pingLoop();
     }
     async receiveLoop() {
-        if (!this.auth) {
+        if (!this.session.authKey) {
             throw new Error("Not connected");
         }
         while (this.connected) {
             if (this.toAcknowledge.size >= ackThreshold) {
-                await this.send(new MsgsAck({ msgIds: [...this.toAcknowledge] }));
+                await this.send(new types.MsgsAck({ msgIds: [...this.toAcknowledge] }));
                 this.toAcknowledge.clear();
             }
             const buffer = await this.transport.receive();
             let decrypted;
             try {
-                decrypted = await decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId);
+                decrypted = await decryptMessage(buffer, this.session.authKey, this.sessionId);
             }
             catch (_err) {
                 // logger().error(`Failed to decrypt message: ${err}`);
@@ -83,21 +93,21 @@ export class Client extends ClientAbstract {
             const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
             for (const message of messages) {
                 let body = message.body;
-                if (body instanceof GZIPPacked) {
+                if (body instanceof types.GZIPPacked) {
                     body = new TLReader(gunzip(body.packedData)).readObject();
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
-                if (body instanceof Updates) {
+                if (body instanceof types.Updates) {
                     this.updatesHandler?.(this, body);
                 }
                 else if (message.body instanceof RPCResult) {
                     let result = message.body.result;
-                    if (result instanceof GZIPPacked) {
+                    if (result instanceof types.GZIPPacked) {
                         result = new TLReader(gunzip(result.packedData)).readObject();
                     }
                     const promise = this.promises.get(message.body.messageId);
                     if (promise) {
-                        if (result instanceof RPCError) {
+                        if (result instanceof types.RPCError) {
                             promise.reject(result);
                         }
                         else {
@@ -106,15 +116,15 @@ export class Client extends ClientAbstract {
                         this.promises.delete(message.body.messageId);
                     }
                 }
-                else if (message.body instanceof Pong) {
+                else if (message.body instanceof types.Pong) {
                     const promise = this.promises.get(message.body.msgId);
                     if (promise) {
                         promise.resolve(message.body);
                         this.promises.delete(message.body.msgId);
                     }
                 }
-                else if (message.body instanceof BadMsgNotification || message.body instanceof BadServerSalt) {
-                    if (message.body instanceof BadServerSalt) {
+                else if (message.body instanceof types.BadMsgNotification || message.body instanceof types.BadServerSalt) {
+                    if (message.body instanceof types.BadServerSalt) {
                         this.state.salt = message.body.newServerSalt;
                     }
                     const promise = this.promises.get(message.body.badMsgId);
@@ -130,7 +140,7 @@ export class Client extends ClientAbstract {
     async pingLoop() {
         while (this.connected) {
             try {
-                await this.invoke(new Ping({ pingId: getRandomBigInt(8, true, false) }));
+                await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
             }
             catch (_err) {
                 // logger().error(`Failed to invoke ping: ${err}`);
@@ -139,16 +149,16 @@ export class Client extends ClientAbstract {
         }
     }
     async invoke(function_, noWait) {
-        if (!this.auth) {
+        if (!this.session.authKey) {
             throw new Error("Not connected");
         }
         let seqNo = this.state.seqNo * 2;
-        if (!(function_ instanceof Ping) && !(function_ instanceof MsgsAck)) {
+        if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
             seqNo++;
             this.state.seqNo++;
         }
         const message = new Message(getMessageId(), seqNo, function_);
-        await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
+        await this.transport.send(await encryptMessage(message, this.session.authKey, this.state.salt, this.sessionId));
         // logger().debug(`Invoked ${function_.constructor.name}`);
         if (noWait) {
             return;
@@ -156,7 +166,7 @@ export class Client extends ClientAbstract {
         const result = await new Promise((resolve, reject) => {
             this.promises.set(message.id, { resolve, reject });
         });
-        if (result instanceof BadServerSalt) {
+        if (result instanceof types.BadServerSalt) {
             return await this.invoke(function_);
         }
         else {

package/esm/client/client_abstract.js

@@ -1,5 +1,5 @@
-import { defaultTransportProvider } from "../transport/transport_provider.js";
 import { initTgCrypto } from "../deps.js";
+import { defaultDc, defaultTransportProvider } from "../transport/transport_provider.js";
 export class ClientAbstract {
     constructor(transportProvider = defaultTransportProvider()) {
         Object.defineProperty(this, "transportProvider", {
@@ -32,7 +32,7 @@ export class ClientAbstract {
             writable: true,
             value: false
         });
-        const { connection, transport, dcId } = transportProvider(false);
+        const { connection, transport, dcId } = transportProvider({ dc: defaultDc, cdn: false });
         this.connection = connection;
         this.transport = transport;
         this.dcId = dcId;

package/esm/client/client_plain.js

@@ -101,11 +101,9 @@ export class ClientPlain extends ClientAbstract {
         const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
         const authKey_ = modExp(gA, b, dhPrime);
         const authKey = bufferFromBigInt(authKey_, 256, false, false);
-        const authKeyId = (await sha1(authKey)).slice(-8);
         // logger().debug("Auth key created");
         return {
             authKey,
-            authKeyId: bigIntFromBuffer(authKeyId, true, false),
             salt: bigIntFromBuffer(salt, true, false),
         };
     }

package/esm/mod.js

@@ -3,10 +3,17 @@ import { getRandomId } from "./utilities/0_bigint.js";
 export const utils = { checkPassword, getRandomId };
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
+export * from "./tl/4_rpc_result.js";
+export * from "./tl/5_message.js";
+export * from "./tl/6_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
+export * from "./session/session.js";
+export * from "./session/session_memory.js";
+export * from "./session/session_local_storage.js";
 export * from "./transport/transport_abridged.js";
 export * from "./transport/transport_intermediate.js";
 export * from "./transport/transport.js";
 export * from "./transport/transport_provider.js";
 export * from "./connection/connection.js";
+export * from "./connection/connection_web_socket.js";

package/esm/session/session.js

@@ -0,0 +1,16 @@
+export class Session {
+    constructor() {
+        Object.defineProperty(this, "dc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "authKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+}

package/esm/session/session_local_storage.js

@@ -0,0 +1,26 @@
+import { Session } from "./session.js";
+export class SessionLocalStorage extends Session {
+    constructor(key) {
+        if (typeof localStorage == "undefined") {
+            throw new Error("Unavailable in current environment");
+        }
+        super();
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: key
+        });
+    }
+    load() {
+        const { dc = null, authKey = null } = JSON.parse(localStorage.getItem(this.key) ?? "{}");
+        this.dc = dc;
+        if (authKey != null) {
+            this.authKey = new Uint8Array(authKey.split(/([0-9a-f]{2})/).filter((v) => v).map((v) => parseInt(v, 16)));
+        }
+    }
+    save() {
+        const authKey = this.authKey == null ? undefined : Array.from(this.authKey).map((v) => v.toString(16)).map((v) => v.padStart(2, "0"));
+        localStorage.setItem(this.key, JSON.stringify({ dc: this.dc, authKey }));
+    }
+}

package/esm/session/session_memory.js

@@ -0,0 +1,5 @@
+import { Session } from "./session.js";
+export class SessionMemory extends Session {
+    load() { }
+    save() { }
+}

package/esm/transport/transport_provider.js

@@ -11,13 +11,13 @@ const dcToNameMap = {
     "4": "vesta",
     "5": "flora",
 };
-export const defaultTransportProvider = (params) => {
-    return (cdn) => {
-        const { dc, wss = typeof location !== "undefined" && location.protocol == "http:" ? false : true } = params ?? { dc: defaultDc };
+export function defaultTransportProvider(wss) {
+    return ({ dc, cdn }) => {
+        wss ??= typeof location !== "undefined" && location.protocol == "http:" ? false : true;
         const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.web.telegram.org/${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
         const connection = new ConnectionWebSocket(url);
         const transport = new TransportIntermediate(connection, true);
         const dcId = Number(dc[0]) + (dc.endsWith("-test") ? 10000 : 0) * (cdn ? -1 : 1);
         return { connection, transport, dcId };
     };
-};
+}

package/esm/utilities/1_message.js

@@ -6,8 +6,12 @@ import { TLReader } from "../tl/3_tl_reader.js";
 import { RPCResult } from "../tl/4_rpc_result.js";
 import { Message } from "../tl/5_message.js";
 import { MessageContainer } from "../tl/6_message_container.js";
+import { bigIntFromBuffer } from "./0_bigint.js";
 import { bufferFromBigInt, concat } from "./0_buffer.js";
-import { sha256 } from "./0_hash.js";
+import { sha1, sha256 } from "./0_hash.js";
+async function getAuthKeyId(authKey) {
+    return bigIntFromBuffer((await sha1(authKey)).slice(-8), true, false);
+}
 let lastMsgId = 0n;
 export function getMessageId() {
     const now = new Date().getTime() / 1000 + 0;
@@ -33,8 +37,9 @@ export function unpackUnencryptedMessage(buffer) {
     const message = reader.read(messageLength);
     return { messageId, message };
 }
-export async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
+export async function encryptMessage(message, authKey, salt, sessionId) {
     const encoded = message.body.serialize();
+    const authKeyId = await getAuthKeyId(authKey);
     const payloadWriter = new TLRawWriter();
     payloadWriter.writeInt64(salt);
     payloadWriter.writeInt64(sessionId);
@@ -61,7 +66,8 @@ export async function encryptMessage(message, authKey, authKeyId, salt, sessionI
     messageWriter.write(ige256Encrypt(payload, aesKey, aesIV));
     return messageWriter.buffer;
 }
-export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
+export async function decryptMessage(buffer, authKey, _sessionId) {
+    const authKeyId = await getAuthKeyId(authKey);
     const reader = new TLReader(buffer);
     assertEquals(reader.readInt64(false), authKeyId);
     const messageKey_ = reader.readInt128();

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "@mtkruto/node",
-  "version": "0.0.63",
+  "version": "0.0.72",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/client/client.js

@@ -1,32 +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.Client = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
-const _2_types_js_1 = require("../tl/2_types.js");
-const _3_functions_js_1 = require("../tl/3_functions.js");
+const types = __importStar(require("../tl/2_types.js"));
+const functions = __importStar(require("../tl/3_functions.js"));
 const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
 const _4_rpc_result_js_1 = require("../tl/4_rpc_result.js");
 const _5_message_js_1 = require("../tl/5_message.js");
 const _6_message_container_js_1 = require("../tl/6_message_container.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
+const session_memory_js_1 = require("../session/session_memory.js");
 class Client extends client_abstract_js_1.ClientAbstract {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "sessionId", {
+    constructor(session = new session_memory_js_1.SessionMemory(), params) {
+        super(params?.transportProvider);
+        Object.defineProperty(this, "session", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false)
+            value: session
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "sessionId", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false)
         });
         Object.defineProperty(this, "state", {
             enumerable: true,
@@ -54,30 +78,39 @@ class Client extends client_abstract_js_1.ClientAbstract {
         });
     }
     async connect() {
-        const plain = new client_plain_js_1.ClientPlain(this.transportProvider);
-        await plain.connect();
-        const { authKey: key, authKeyId: id, salt } = await plain.createAuthKey();
-        await plain.disconnect();
-        this.auth = { key, id };
-        this.state.salt = salt;
+        await this.session.load();
+        if (this.session.authKey == null) {
+            const plain = new client_plain_js_1.ClientPlain(this.transportProvider);
+            await plain.connect();
+            const { authKey, salt } = await plain.createAuthKey();
+            await plain.disconnect();
+            this.state.salt = salt;
+            this.session.authKey = authKey;
+        }
+        if (this.session.dc != null) {
+            const { connection, transport, dcId } = this.transportProvider({ dc: this.session.dc, cdn: false });
+            this.connection = connection;
+            this.transport = transport;
+            this.dcId = dcId;
+        }
         await super.connect();
         // logger().debug("Client connected");
         this.receiveLoop();
         this.pingLoop();
     }
     async receiveLoop() {
-        if (!this.auth) {
+        if (!this.session.authKey) {
             throw new Error("Not connected");
         }
         while (this.connected) {
             if (this.toAcknowledge.size >= constants_js_1.ackThreshold) {
-                await this.send(new _2_types_js_1.MsgsAck({ msgIds: [...this.toAcknowledge] }));
+                await this.send(new types.MsgsAck({ msgIds: [...this.toAcknowledge] }));
                 this.toAcknowledge.clear();
             }
             const buffer = await this.transport.receive();
             let decrypted;
             try {
-                decrypted = await (0, _1_message_js_1.decryptMessage)(buffer, this.auth.key, this.auth.id, this.sessionId);
+                decrypted = await (0, _1_message_js_1.decryptMessage)(buffer, this.session.authKey, this.sessionId);
             }
             catch (_err) {
                 // logger().error(`Failed to decrypt message: ${err}`);
@@ -86,21 +119,21 @@ class Client extends client_abstract_js_1.ClientAbstract {
             const messages = decrypted instanceof _6_message_container_js_1.MessageContainer ? decrypted.messages : [decrypted];
             for (const message of messages) {
                 let body = message.body;
-                if (body instanceof _2_types_js_1.GZIPPacked) {
+                if (body instanceof types.GZIPPacked) {
                     body = new _3_tl_reader_js_1.TLReader((0, deps_js_1.gunzip)(body.packedData)).readObject();
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
-                if (body instanceof _2_types_js_1.Updates) {
+                if (body instanceof types.Updates) {
                     this.updatesHandler?.(this, body);
                 }
                 else if (message.body instanceof _4_rpc_result_js_1.RPCResult) {
                     let result = message.body.result;
-                    if (result instanceof _2_types_js_1.GZIPPacked) {
+                    if (result instanceof types.GZIPPacked) {
                         result = new _3_tl_reader_js_1.TLReader((0, deps_js_1.gunzip)(result.packedData)).readObject();
                     }
                     const promise = this.promises.get(message.body.messageId);
                     if (promise) {
-                        if (result instanceof _2_types_js_1.RPCError) {
+                        if (result instanceof types.RPCError) {
                             promise.reject(result);
                         }
                         else {
@@ -109,15 +142,15 @@ class Client extends client_abstract_js_1.ClientAbstract {
                         this.promises.delete(message.body.messageId);
                     }
                 }
-                else if (message.body instanceof _2_types_js_1.Pong) {
+                else if (message.body instanceof types.Pong) {
                     const promise = this.promises.get(message.body.msgId);
                     if (promise) {
                         promise.resolve(message.body);
                         this.promises.delete(message.body.msgId);
                     }
                 }
-                else if (message.body instanceof _2_types_js_1.BadMsgNotification || message.body instanceof _2_types_js_1.BadServerSalt) {
-                    if (message.body instanceof _2_types_js_1.BadServerSalt) {
+                else if (message.body instanceof types.BadMsgNotification || message.body instanceof types.BadServerSalt) {
+                    if (message.body instanceof types.BadServerSalt) {
                         this.state.salt = message.body.newServerSalt;
                     }
                     const promise = this.promises.get(message.body.badMsgId);
@@ -133,7 +166,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
     async pingLoop() {
         while (this.connected) {
             try {
-                await this.invoke(new _3_functions_js_1.Ping({ pingId: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false) }));
+                await this.invoke(new functions.Ping({ pingId: (0, _0_bigint_js_1.getRandomBigInt)(8, true, false) }));
             }
             catch (_err) {
                 // logger().error(`Failed to invoke ping: ${err}`);
@@ -142,16 +175,16 @@ class Client extends client_abstract_js_1.ClientAbstract {
         }
     }
     async invoke(function_, noWait) {
-        if (!this.auth) {
+        if (!this.session.authKey) {
             throw new Error("Not connected");
         }
         let seqNo = this.state.seqNo * 2;
-        if (!(function_ instanceof _3_functions_js_1.Ping) && !(function_ instanceof _2_types_js_1.MsgsAck)) {
+        if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
             seqNo++;
             this.state.seqNo++;
         }
         const message = new _5_message_js_1.Message((0, _1_message_js_1.getMessageId)(), seqNo, function_);
-        await this.transport.send(await (0, _1_message_js_1.encryptMessage)(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
+        await this.transport.send(await (0, _1_message_js_1.encryptMessage)(message, this.session.authKey, this.state.salt, this.sessionId));
         // logger().debug(`Invoked ${function_.constructor.name}`);
         if (noWait) {
             return;
@@ -159,7 +192,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
         const result = await new Promise((resolve, reject) => {
             this.promises.set(message.id, { resolve, reject });
         });
-        if (result instanceof _2_types_js_1.BadServerSalt) {
+        if (result instanceof types.BadServerSalt) {
             return await this.invoke(function_);
         }
         else {

package/script/client/client_abstract.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientAbstract = void 0;
-const transport_provider_js_1 = require("../transport/transport_provider.js");
 const deps_js_1 = require("../deps.js");
+const transport_provider_js_1 = require("../transport/transport_provider.js");
 class ClientAbstract {
     constructor(transportProvider = (0, transport_provider_js_1.defaultTransportProvider)()) {
         Object.defineProperty(this, "transportProvider", {
@@ -35,7 +35,7 @@ class ClientAbstract {
             writable: true,
             value: false
         });
-        const { connection, transport, dcId } = transportProvider(false);
+        const { connection, transport, dcId } = transportProvider({ dc: transport_provider_js_1.defaultDc, cdn: false });
         this.connection = connection;
         this.transport = transport;
         this.dcId = dcId;

package/script/client/client_plain.js

@@ -104,11 +104,9 @@ class ClientPlain extends client_abstract_js_1.ClientAbstract {
         const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
         const authKey_ = (0, _0_bigint_js_1.modExp)(gA, b, dhPrime);
         const authKey = (0, _0_buffer_js_1.bufferFromBigInt)(authKey_, 256, false, false);
-        const authKeyId = (await (0, _0_hash_js_1.sha1)(authKey)).slice(-8);
         // logger().debug("Auth key created");
         return {
             authKey,
-            authKeyId: (0, _0_bigint_js_1.bigIntFromBuffer)(authKeyId, true, false),
             salt: (0, _0_bigint_js_1.bigIntFromBuffer)(salt, true, false),
         };
     }

package/script/mod.js

@@ -32,10 +32,17 @@ const _0_bigint_js_1 = require("./utilities/0_bigint.js");
 exports.utils = { checkPassword: _1_password_js_1.checkPassword, getRandomId: _0_bigint_js_1.getRandomId };
 exports.types = __importStar(require("./tl/2_types.js"));
 exports.functions = __importStar(require("./tl/3_functions.js"));
+__exportStar(require("./tl/4_rpc_result.js"), exports);
+__exportStar(require("./tl/5_message.js"), exports);
+__exportStar(require("./tl/6_message_container.js"), exports);
 __exportStar(require("./client/client_plain.js"), exports);
 __exportStar(require("./client/client.js"), exports);
+__exportStar(require("./session/session.js"), exports);
+__exportStar(require("./session/session_memory.js"), exports);
+__exportStar(require("./session/session_local_storage.js"), exports);
 __exportStar(require("./transport/transport_abridged.js"), exports);
 __exportStar(require("./transport/transport_intermediate.js"), exports);
 __exportStar(require("./transport/transport.js"), exports);
 __exportStar(require("./transport/transport_provider.js"), exports);
 __exportStar(require("./connection/connection.js"), exports);
+__exportStar(require("./connection/connection_web_socket.js"), exports);

package/script/session/session.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+class Session {
+    constructor() {
+        Object.defineProperty(this, "dc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "authKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+}
+exports.Session = Session;

package/script/session/session_local_storage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionLocalStorage = void 0;
+const session_js_1 = require("./session.js");
+class SessionLocalStorage extends session_js_1.Session {
+    constructor(key) {
+        if (typeof localStorage == "undefined") {
+            throw new Error("Unavailable in current environment");
+        }
+        super();
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: key
+        });
+    }
+    load() {
+        const { dc = null, authKey = null } = JSON.parse(localStorage.getItem(this.key) ?? "{}");
+        this.dc = dc;
+        if (authKey != null) {
+            this.authKey = new Uint8Array(authKey.split(/([0-9a-f]{2})/).filter((v) => v).map((v) => parseInt(v, 16)));
+        }
+    }
+    save() {
+        const authKey = this.authKey == null ? undefined : Array.from(this.authKey).map((v) => v.toString(16)).map((v) => v.padStart(2, "0"));
+        localStorage.setItem(this.key, JSON.stringify({ dc: this.dc, authKey }));
+    }
+}
+exports.SessionLocalStorage = SessionLocalStorage;

package/script/session/session_memory.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionMemory = void 0;
+const session_js_1 = require("./session.js");
+class SessionMemory extends session_js_1.Session {
+    load() { }
+    save() { }
+}
+exports.SessionMemory = SessionMemory;

package/script/transport/transport_provider.js

@@ -14,14 +14,14 @@ const dcToNameMap = {
     "4": "vesta",
     "5": "flora",
 };
-const defaultTransportProvider = (params) => {
-    return (cdn) => {
-        const { dc, wss = typeof location !== "undefined" && location.protocol == "http:" ? false : true } = params ?? { dc: exports.defaultDc };
+function defaultTransportProvider(wss) {
+    return ({ dc, cdn }) => {
+        wss ??= typeof location !== "undefined" && location.protocol == "http:" ? false : true;
         const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.web.telegram.org/${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/utilities/1_message.js

@@ -9,8 +9,12 @@ const _3_tl_reader_js_1 = require("../tl/3_tl_reader.js");
 const _4_rpc_result_js_1 = require("../tl/4_rpc_result.js");
 const _5_message_js_1 = require("../tl/5_message.js");
 const _6_message_container_js_1 = require("../tl/6_message_container.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 getAuthKeyId(authKey) {
+    return (0, _0_bigint_js_1.bigIntFromBuffer)((await (0, _0_hash_js_1.sha1)(authKey)).slice(-8), true, false);
+}
 let lastMsgId = 0n;
 function getMessageId() {
     const now = new Date().getTime() / 1000 + 0;
@@ -39,8 +43,9 @@ function unpackUnencryptedMessage(buffer) {
     return { messageId, message };
 }
 exports.unpackUnencryptedMessage = unpackUnencryptedMessage;
-async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
+async function encryptMessage(message, authKey, salt, sessionId) {
     const encoded = message.body.serialize();
+    const authKeyId = await getAuthKeyId(authKey);
     const payloadWriter = new _0_tl_raw_writer_js_1.TLRawWriter();
     payloadWriter.writeInt64(salt);
     payloadWriter.writeInt64(sessionId);
@@ -68,7 +73,8 @@ async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
     return messageWriter.buffer;
 }
 exports.encryptMessage = encryptMessage;
-async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
+async function decryptMessage(buffer, authKey, _sessionId) {
+    const authKeyId = await getAuthKeyId(authKey);
     const reader = new _3_tl_reader_js_1.TLReader(buffer);
     (0, deps_js_1.assertEquals)(reader.readInt64(false), authKeyId);
     const messageKey_ = reader.readInt128();

package/types/client/client.d.ts

@@ -1,19 +1,24 @@
 import { MaybePromise } from "../types.js";
-import { Type, Updates } from "../tl/2_types.js";
-import { Function } from "../tl/3_functions.js";
+import * as types from "../tl/2_types.js";
+import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
-export type UpdatesHandler = null | ((client: Client, update: Updates) => MaybePromise<void>);
+import { Session } from "../session/session.js";
+import { TransportProvider } from "../transport/transport_provider.js";
+export type UpdatesHandler = null | ((client: Client, update: types.Updates) => MaybePromise<void>);
 export declare class Client extends ClientAbstract {
+    readonly session: Session;
     private sessionId;
-    private auth?;
     private state;
     private promises;
     private toAcknowledge;
     updatesHandler: UpdatesHandler;
+    constructor(session?: Session, params?: {
+        transportProvider?: TransportProvider;
+    });
     connect(): Promise<void>;
     private receiveLoop;
     private pingLoop;
-    invoke<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T): Promise<T extends Function<unknown> ? T["__R"] : void>;
-    invoke<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T, noWait: true): Promise<void>;
-    send<T extends (Function<unknown> | Type) = Function<unknown>>(function_: T): Promise<void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
 }

package/types/client/client_abstract.d.ts

@@ -1,20 +1,12 @@
 import { Connection } from "../connection/connection.js";
 import { Transport } from "../transport/transport.js";
 export declare abstract class ClientAbstract {
-    protected transportProvider: (cdn: boolean) => {
-        connection: Connection;
-        transport: Transport;
-        dcId: number;
-    };
-    connection: Connection;
-    transport: Transport;
+    protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
+    protected connection: Connection;
+    protected transport: Transport;
     dcId: number;
     protected connected: boolean;
-    constructor(transportProvider?: (cdn: boolean) => {
-        connection: Connection;
-        transport: Transport;
-        dcId: number;
-    });
+    constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
 }

package/types/client/client_plain.d.ts

@@ -4,7 +4,6 @@ export declare class ClientPlain extends ClientAbstract {
     invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
     createAuthKey(): Promise<{
         authKey: Uint8Array;
-        authKeyId: bigint;
         salt: bigint;
     }>;
 }

package/types/mod.d.ts

@@ -6,10 +6,17 @@ export declare const utils: {
 };
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
+export * from "./tl/4_rpc_result.js";
+export * from "./tl/5_message.js";
+export * from "./tl/6_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
+export * from "./session/session.js";
+export * from "./session/session_memory.js";
+export * from "./session/session_local_storage.js";
 export * from "./transport/transport_abridged.js";
 export * from "./transport/transport_intermediate.js";
 export * from "./transport/transport.js";
 export * from "./transport/transport_provider.js";
 export * from "./connection/connection.js";
+export * from "./connection/connection_web_socket.js";

package/types/session/session.d.ts

@@ -0,0 +1,8 @@
+import { MaybePromise } from "../types.js";
+import { TransportProviderParams } from "../transport/transport_provider.js";
+export declare abstract class Session {
+    dc: TransportProviderParams["dc"] | null;
+    authKey: Uint8Array | null;
+    abstract load(): MaybePromise<void>;
+    abstract save(): MaybePromise<void>;
+}

package/types/session/session_local_storage.d.ts

@@ -0,0 +1,7 @@
+import { Session } from "./session.js";
+export declare class SessionLocalStorage extends Session implements Session {
+    private readonly key;
+    constructor(key: string);
+    load(): void;
+    save(): void;
+}

package/types/session/session_memory.d.ts

@@ -0,0 +1,5 @@
+import { Session } from "./session.js";
+export declare class SessionMemory extends Session implements Session {
+    load(): void;
+    save(): void;
+}

package/types/transport/transport_provider.d.ts

@@ -2,11 +2,12 @@ import { Connection } from "../connection/connection.js";
 import { Transport } from "./transport.js";
 export interface TransportProviderParams {
     dc: "1" | "2" | "3" | "4" | "5" | "1-test" | "2-test" | "3-test";
+    cdn: boolean;
 }
-export type TransportProvider = (params?: TransportProviderParams) => (cdn: boolean) => {
+export type TransportProvider = (params: TransportProviderParams) => {
     connection: Connection;
     transport: Transport;
     dcId: number;
 };
 export declare const defaultDc: TransportProviderParams["dc"];
-export declare const defaultTransportProvider: TransportProvider;
+export declare function defaultTransportProvider(wss?: boolean): TransportProvider;

package/types/utilities/1_message.d.ts

@@ -6,5 +6,5 @@ export declare function unpackUnencryptedMessage(buffer: Uint8Array): {
     messageId: bigint;
     message: Uint8Array;
 };
-export declare function encryptMessage(message: Message, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
-export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message | MessageContainer>;
+export declare function encryptMessage(message: Message, authKey: Uint8Array, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
+export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, _sessionId: bigint): Promise<Message | MessageContainer>;