@mtkruto/browser 0.6.0 → 0.119.0

package/esm/client/0_storage_operations.js

@@ -1,6 +1,6 @@
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -28,27 +28,23 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _StorageOperations_instances, _StorageOperations_storage, _StorageOperations_supportsFiles, _StorageOperations_mustSerialize, _StorageOperations_authKeyId, _StorageOperations_resetAuthKeyId, _StorageOperations_accountId, _StorageOperations_accountType, _StorageOperations_getUpdateId;
-import { unreachable } from "../0_deps.js";
+var _StorageOperations_instances, _StorageOperations_storage, _StorageOperations_supportsFiles, _StorageOperations_mustSerialize, _StorageOperations_L, _StorageOperations_maps, _StorageOperations_values, _StorageOperations_addMap, _StorageOperations_addValue, _StorageOperations_lastCommit, _StorageOperations_accountId, _StorageOperations_getUpdateId, _StorageMap_storage, _StorageMap_path, _StorageMap_pendingUpdates, _StorageMap_cache, _StorageValue_storage, _StorageValue_key, _StorageValue_updatePending, _StorageValue_value, _StorageAuth_instances, _StorageAuth_authKeyId, _StorageAuth_resetAuthKeyId;
+import { MINUTE } from "../0_deps.js";
+import { LruCache, unreachable } from "../0_deps.js";
 import { InputError } from "../0_errors.js";
-import { base64DecodeUrlSafe, base64EncodeUrlSafe, bigIntFromBuffer, rleDecode, rleEncode, sha1, ZERO_CHANNEL_ID } from "../1_utilities.js";
-import { as, is, isValidType, peerToChatId, serialize, TLReader, TLWriter } from "../2_tl.js";
-// key parts
+import { base64DecodeUrlSafe, base64EncodeUrlSafe, getLogger, intFromBytes, rleDecode, rleEncode, sha1, ZERO_CHANNEL_ID } from "../1_utilities.js";
+import { awaitablePooledMap } from "../1_utilities.js";
+import { fromString, toString } from "../2_storage.js";
+import { Api, TLReader, TLWriter, X } from "../2_tl.js";
+import { constructChatP } from "../3_types.js";
 export const K = {
-    connection: {
-        P: (string) => `connection.${string}`,
-        apiId: () => [K.connection.P("apiId")],
-    },
     session: {
         P: (string) => `session.${string}`,
         serverSalt: () => [K.session.P("serverSalt")],
     },
     auth: {
         P: (string) => `auth.${string}`,
-        dc: () => [K.auth.P("dc")],
-        key: () => [K.auth.P("key")],
-        accountId: () => [K.auth.P("accountId")],
-        accountType: () => [K.auth.P("accountType")],
+        isPremium: () => [K.auth.P("isPremium")],
     },
     updates: {
         P: (string) => `updates.${string}`,
@@ -56,14 +52,9 @@ export const K = {
         all: () => [K.updates.P("updates")],
         updates: (boxId) => [...K.updates.all(), boxId],
         update: (boxId, id) => [...K.updates.updates(boxId), id],
-        channelPts: (channelId) => [K.updates.P("channelPts"), channelId],
     },
     cache: {
         P: (string) => `cache.${string}`,
-        usernames: () => [K.cache.P("username")],
-        username: (v) => [...K.cache.usernames(), v],
-        peers: () => [K.cache.P("peer")],
-        peer: (id) => [...K.cache.peers(), id],
         stickerSetNames: () => [K.cache.P("stickerSetNames")],
         stickerSetName: (id, accessHash) => [...K.cache.stickerSetNames(), id, accessHash],
         files: () => [K.cache.P("files")],
@@ -84,9 +75,14 @@ export const K = {
         groupCall: (id) => [...K.cache.groupCalls(), id],
         groupCallAccessHashes: () => [K.cache.P("groupCallAccessHashes")],
         groupCallAccessHash: (id) => [...K.cache.groupCallAccessHashes(), id],
-        minPeerReferences: () => ["minPeerReferences"],
-        minPeerReference: (senderId, chatId) => [...K.cache.minPeerReferences(), senderId, chatId],
-        minPeerReferenceSender: (senderId) => [...K.cache.minPeerReferences(), senderId],
+        pollResults: () => [K.cache.P("pollResults")],
+        pollResult: (pollId) => [...K.cache.pollResults(), pollId],
+        polls: () => [K.cache.P("polls")],
+        poll: (pollId) => [...K.cache.polls(), pollId],
+        voiceTranscriptions: () => [K.cache.P("voiceTranscriptions")],
+        voiceTranscription: (transcriptionId) => [...K.cache.voiceTranscriptions(), transcriptionId],
+        voiceTranscriptionReferences: () => [K.cache.P("voiceTranscriptions")],
+        voiceTranscriptionReference: (chatId, messageId, messageEditDate) => [...K.cache.voiceTranscriptionReferences(), chatId, messageId, messageEditDate],
     },
     messages: {
         P: (string) => `messages.${string}`,
@@ -95,13 +91,6 @@ export const K = {
         allMessageRefs: () => [K.messages.P("messageRefs")],
         messageRef: (messageId) => [...K.messages.allMessageRefs(), messageId],
     },
-    chatlists: {
-        P: (string) => `chatlists.${string}`,
-        hasAllChats: (listId) => [K.chatlists.P("hasAllChats"), listId],
-        chats: (listId) => [K.chatlists.P("chats"), listId],
-        chat: (listId, chatId) => [...K.chatlists.chats(listId), chatId],
-        pinnedChats: (listId) => [K.chatlists.P("pinnedChats"), listId],
-    },
 };
 export class StorageOperations {
     constructor(storage) {
@@ -109,12 +98,50 @@ export class StorageOperations {
         _StorageOperations_storage.set(this, void 0);
         _StorageOperations_supportsFiles.set(this, void 0);
         _StorageOperations_mustSerialize.set(this, void 0);
-        _StorageOperations_authKeyId.set(this, null);
+        _StorageOperations_L.set(this, void 0);
+        _StorageOperations_maps.set(this, new Array());
+        _StorageOperations_values.set(this, new Array());
+        Object.defineProperty(this, "auth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "channelPts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "peers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usernames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "translations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _StorageOperations_lastCommit.set(this, null);
         _StorageOperations_accountId.set(this, null);
-        _StorageOperations_accountType.set(this, null);
         __classPrivateFieldSet(this, _StorageOperations_storage, storage, "f");
         __classPrivateFieldSet(this, _StorageOperations_supportsFiles, storage.supportsFiles, "f");
         __classPrivateFieldSet(this, _StorageOperations_mustSerialize, storage.mustSerialize, "f");
+        __classPrivateFieldSet(this, _StorageOperations_L, getLogger("StorageOperations"), "f");
+        this.auth = __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_addValue).call(this, new StorageAuth(storage));
+        this.channelPts = __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_addMap).call(this, new StorageMap(storage, "channelPts"));
+        this.peers = __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_addMap).call(this, new StorageMap(storage, "peers"));
+        this.usernames = __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_addMap).call(this, new StorageMap(storage, "usernames"));
+        this.translations = __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_addMap).call(this, new StorageMap(storage, "translations"));
     }
     get provider() {
         return __classPrivateFieldGet(this, _StorageOperations_storage, "f");
@@ -124,7 +151,7 @@ export class StorageOperations {
     }
     async initialize() {
         await __classPrivateFieldGet(this, _StorageOperations_storage, "f").initialize();
-        await this.getAccountType();
+        await this.auth.get();
     }
     set(...args) {
         return __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(...args);
@@ -135,41 +162,20 @@ export class StorageOperations {
     get(...args) {
         return __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(...args);
     }
-    getMany(...args) {
-        return __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany(...args);
-    }
-    async setDc(dc) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.auth.dc(), dc);
-    }
-    getDc() {
-        return __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.auth.dc());
-    }
-    async getAuthKey() {
-        const authKey = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.auth.key());
-        await __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_resetAuthKeyId).call(this, authKey);
-        return authKey;
-    }
-    async setAuthKey(authKey) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.auth.key(), authKey);
-        await __classPrivateFieldGet(this, _StorageOperations_instances, "m", _StorageOperations_resetAuthKeyId).call(this, authKey);
-    }
-    get authKeyId() {
-        return __classPrivateFieldGet(this, _StorageOperations_authKeyId, "f");
-    }
     async exportAuthString(apiId_) {
         if (typeof apiId_ === "number") {
-            await this.setApiId(apiId_);
+            await this.auth.update((v) => v.apiId = apiId_);
         }
-        const [dc, authKey, apiId, accountId, accountType] = await Promise.all([this.getDc(), this.getAuthKey(), this.getApiId(), this.getAccountId(), this.getAccountType()]);
-        if (dc == null || authKey == null || apiId == null || accountId == null || accountType == null) {
+        const auth = this.auth.mustGet();
+        if (auth.dc === null || auth.authKey === null || auth.apiId === 0 || auth.userId === 0) {
             throw new Error("Not authorized");
         }
         const writer = new TLWriter();
-        writer.writeString(dc);
-        writer.writeBytes(authKey);
-        writer.writeInt32(apiId);
-        writer.write(new Uint8Array([accountType == "bot" ? 1 : 0]));
-        writer.writeInt64(BigInt(accountId));
+        writer.writeString(auth.dc);
+        writer.writeBytes(auth.authKey);
+        writer.writeInt32(auth.apiId);
+        writer.write(new Uint8Array([auth.isBot ? 1 : 0]));
+        writer.writeInt64(BigInt(auth.userId));
         const data = rleEncode(writer.buffer);
         return base64EncodeUrlSafe(data);
     }
@@ -179,68 +185,72 @@ export class StorageOperations {
         const dc = reader.readString();
         const authKey = reader.readBytes();
         const apiId = reader.readInt32();
-        const isBot = reader.read(1)[0];
-        const accountId = Number(reader.readInt64());
-        await this.setAccountId(accountId);
-        await this.setAccountType(isBot ? "bot" : "user");
-        await this.setApiId(apiId);
-        await this.setDc(dc);
-        await this.setAuthKey(authKey);
-    }
-    async getChannelAccessHash(id) {
-        const channel = await this.getEntity(id);
-        if (channel) {
-            if (!(is("channel", channel)) && !is("channelForbidden", channel)) {
-                unreachable();
-            }
-            if (is("channel", channel) && channel.min) {
-                return null;
-            }
-            return typeof channel.access_hash === "bigint" ? channel.access_hash : null;
+        const isBot = !!reader.read(1)[0];
+        const userId = Number(reader.readInt64());
+        await this.auth.set({
+            apiId,
+            authKey,
+            dc,
+            isBot,
+            userId,
+        });
+    }
+    async commit(force = false) {
+        if (__classPrivateFieldGet(this, _StorageOperations_storage, "f").isMemory) {
+            return;
         }
-        else {
-            return null;
+        const pending = __classPrivateFieldGet(this, _StorageOperations_values, "f").filter((v) => v.isUpdatePending).length + __classPrivateFieldGet(this, _StorageOperations_maps, "f").filter((v) => v.pendingUpdateCount > 0).length;
+        if (pending <= 0) {
+            __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("nothing to commit");
+            return;
         }
-    }
-    async getUserAccessHash(id) {
-        const user = await this.getEntity(id);
-        if (user) {
-            if (!is("user", user)) {
-                unreachable();
-            }
-            if (user.min) {
-                return null;
-            }
-            return typeof user.access_hash === "bigint" ? user.access_hash : null;
+        let commit = false;
+        if (force) {
+            __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("committing because force = true");
+            commit = true;
         }
         else {
-            return null;
+            if (!commit && pending >= 1_000) {
+                __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("committing because pending writes >= threshold");
+                commit = true;
+            }
+            else if (__classPrivateFieldGet(this, _StorageOperations_lastCommit, "f") === null) {
+                __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("committing because there is no last commit");
+                commit = true;
+            }
+            else if (Date.now() - __classPrivateFieldGet(this, _StorageOperations_lastCommit, "f").getTime() >= 5 * MINUTE) {
+                __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("committing because last commit is older than threshold");
+                commit = true;
+            }
+            else {
+                __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("not committing");
+            }
         }
-    }
-    async updateUsernames(id, usernames) {
-        for (let username of usernames) {
-            username = username.toLowerCase();
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.username(username), [id, new Date()]);
+        if (commit) {
+            const values = __classPrivateFieldGet(this, _StorageOperations_values, "f").filter((v) => v.isUpdatePending).map((v) => v.commit());
+            const maps = __classPrivateFieldGet(this, _StorageOperations_maps, "f").filter((v) => v.pendingUpdateCount > 0).map((v) => v.commit());
+            await Promise.all(values.concat(maps));
+            __classPrivateFieldGet(this, _StorageOperations_L, "f").debug("committed", values.length, "value(s) and", maps.length, "map(s)");
+            __classPrivateFieldSet(this, _StorageOperations_lastCommit, new Date(), "f");
         }
     }
-    async getUsername(username) {
-        username = username.toLowerCase();
-        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.username(username));
-    }
     async setTlObject(key, value) {
-        if (value == null) {
+        if (value === null) {
             await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
         }
         else {
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, __classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(value)) : value);
+            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, __classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? [value._, rleEncode(Api.serializeObject(value))] : value);
         }
     }
     async getTlObject(keyOrBuffer) {
         // @ts-ignore: TBD
-        const buffer = (keyOrBuffer instanceof Uint8Array || isValidType(keyOrBuffer)) ? keyOrBuffer : await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(keyOrBuffer);
-        if (buffer != null) {
+        const buffer = (keyOrBuffer instanceof Uint8Array || Api.isValidObject(keyOrBuffer)) ? keyOrBuffer : await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(keyOrBuffer);
+        if (buffer !== null) {
             if (buffer instanceof Uint8Array) {
-                return new TLReader(rleDecode(buffer)).readObject();
+                return await Api.deserializeType(X, rleDecode(buffer));
+            }
+            else if (Array.isArray(buffer)) {
+                return await Api.deserializeType(buffer[0], rleDecode(buffer[1]));
             }
             else {
                 return buffer;
@@ -258,14 +268,14 @@ export class StorageOperations {
     }
     async setMessage(chatId, messageId, message) {
         if (chatId > ZERO_CHANNEL_ID) {
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.messages.messageRef(messageId), message == null ? null : chatId);
+            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.messages.messageRef(messageId), message === null ? null : chatId);
         }
         await this.setTlObject(K.messages.message(chatId, messageId), message);
     }
     async deleteMessages() {
         const maybePromises = new Array();
         for await (const [k, o] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.messages.allMessageRefs() })) {
-            maybePromises.push(Promise.all([__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(k, null), o == null ? Promise.resolve() : __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.messages.message(o, k[1]), null)]));
+            maybePromises.push(Promise.all([__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(k, null), o === null ? Promise.resolve() : __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.messages.message(o, k[1]), null)]));
         }
         await Promise.all(maybePromises.filter((v) => v instanceof Promise));
     }
@@ -275,59 +285,26 @@ export class StorageOperations {
     async getMessage(chatId, messageId) {
         return await this.getTlObject(K.messages.message(chatId, messageId));
     }
-    async getLastMessage(chatId) {
-        for await (const [_, buffer] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.messages.messages(chatId) }, { limit: 1, reverse: true })) {
-            return await this.getTlObject(buffer);
-        }
-        return null;
-    }
-    async setChannelPts(channelId, pts) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.updates.channelPts(channelId), pts);
+    setPeer(peer_) {
+        const chatP = constructChatP(peer_);
+        this.setPeer2(chatP, "access_hash" in peer_ ? peer_.access_hash ?? 0n : 0n);
     }
-    getChannelPts(channelId) {
-        return __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.updates.channelPts(channelId));
-    }
-    async setEntity(entity) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.peer(peerToChatId(entity)), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(entity)) : entity, new Date()]);
-    }
-    async getEntity(key) {
-        const peer_ = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.peer(key));
-        if (peer_ != null) {
-            const [obj_] = peer_;
-            return await this.getTlObject(obj_);
-        }
-        else {
-            return null;
-        }
-    }
-    async setAccountId(accountId) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.auth.accountId(), accountId);
+    setPeer2(chatP, accessHash) {
+        this.peers.set([chatP.id], [chatP, accessHash]);
     }
     async getAccountId() {
-        if (__classPrivateFieldGet(this, _StorageOperations_accountId, "f") != null) {
+        if (__classPrivateFieldGet(this, _StorageOperations_accountId, "f") !== null) {
             return __classPrivateFieldGet(this, _StorageOperations_accountId, "f");
         }
         else {
-            return (__classPrivateFieldSet(this, _StorageOperations_accountId, await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.auth.accountId()), "f"));
+            return __classPrivateFieldSet(this, _StorageOperations_accountId, (await this.auth.get())?.userId ?? null, "f");
         }
     }
-    async setAccountType(type) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.auth.accountType(), type);
-        await this.getAccountType();
-    }
-    async getAccountType() {
-        if (__classPrivateFieldGet(this, _StorageOperations_accountType, "f") != null) {
-            return __classPrivateFieldGet(this, _StorageOperations_accountType, "f");
-        }
-        else {
-            return __classPrivateFieldSet(this, _StorageOperations_accountType, await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.auth.accountType()), "f");
-        }
+    async setIsPremium(isPremium) {
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.auth.isPremium(), isPremium);
     }
-    get accountType() {
-        if (__classPrivateFieldGet(this, _StorageOperations_accountType, "f") == null) {
-            unreachable();
-        }
-        return __classPrivateFieldGet(this, _StorageOperations_accountType, "f");
+    async getIsPremium() {
+        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.auth.isPremium());
     }
     async updateStickerSetName(id, accessHash, name) {
         await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.stickerSetName(id, accessHash), [name, new Date()]);
@@ -341,48 +318,15 @@ export class StorageOperations {
     getServerSalt() {
         return __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.session.serverSalt());
     }
-    async setChat(listId, chatId, pinned, topMessageId, topMessageDate) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.chatlists.chat(listId, chatId), [pinned, topMessageId, topMessageDate]);
-    }
-    async getChats(listId) {
-        const chats = new Array();
-        for await (const [key, value] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.chatlists.chats(listId) })) {
-            if (key.length != 3 || typeof key[2] !== "number") {
-                continue;
-            }
-            chats.push({ chatId: key[2], pinned: value[0], topMessageId: value[1], topMessageDate: value[2] });
-        }
-        return chats;
-    }
-    async removeChats(listId) {
-        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.chatlists.chats(listId) })) {
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
-        }
-        await this.setHasAllChats(listId, false);
-        await this.setPinnedChats(listId, null);
-    }
-    async setHasAllChats(listId, hasAllChats) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.chatlists.hasAllChats(listId), hasAllChats);
-    }
-    async hasAllChats(listId) {
-        const v = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.chatlists.hasAllChats(listId));
-        return v == true;
-    }
-    async setPinnedChats(listId, chatIds) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.chatlists.pinnedChats(listId), chatIds);
-    }
-    async getPinnedChats(listId) {
-        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.chatlists.pinnedChats(listId));
-    }
     async getHistory(chatId, offsetId, limit) {
-        if (offsetId == 0) {
+        if (offsetId === 0) {
             offsetId = Infinity;
         }
         ++limit;
         const messages = new Array();
         for await (const [_, buffer] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ start: K.messages.message(chatId, 0), end: K.messages.message(chatId, offsetId) }, { limit, reverse: true })) {
             const message = await this.getTlObject(buffer);
-            if ("id" in message && message.id == offsetId) {
+            if ("id" in message && message.id === offsetId) {
                 continue;
             }
             messages.push(message);
@@ -402,7 +346,7 @@ export class StorageOperations {
         for (let i = offset; i < partCount; i++) {
             signal?.throwIfAborted();
             const part = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.filePart(id, i));
-            if (part == null) {
+            if (part === null) {
                 continue;
             }
             yield part;
@@ -421,11 +365,11 @@ export class StorageOperations {
         await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.file(id), [partCount, chunkSize]);
     }
     async setCustomEmojiDocument(id, document) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.customEmojiDocument(id), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(document)) : document, new Date()]);
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.customEmojiDocument(id), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(Api.serializeObject(document)) : document, new Date()]);
     }
     async getCustomEmojiDocument(id) {
         const v = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.customEmojiDocument(id));
-        if (v != null) {
+        if (v !== null) {
             return [await this.getTlObject(v[0]), v[1]];
         }
         else {
@@ -433,11 +377,11 @@ export class StorageOperations {
         }
     }
     async setBusinessConnection(id, connection) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.businessConnection(id), connection == null ? null : __classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(connection)) : connection);
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.businessConnection(id), connection === null ? null : __classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(Api.serializeObject(connection)) : connection);
     }
     async getBusinessConnection(id) {
         const v = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.businessConnection(id));
-        if (v != null) {
+        if (v !== null) {
             return await this.getTlObject(v);
         }
         else {
@@ -445,26 +389,26 @@ export class StorageOperations {
         }
     }
     async setInlineQueryAnswer(userId, chatId, query, offset, results, date) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.inlineQueryAnswer(userId, chatId, query, offset), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(results)) : results, date]);
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.inlineQueryAnswer(userId, chatId, query, offset), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(Api.serializeObject(results)) : results, date]);
     }
     async getInlineQueryAnswer(userId, chatId, query, offset) {
         const peer_ = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.inlineQueryAnswer(userId, chatId, query, offset));
-        if (peer_ != null) {
+        if (peer_ !== null) {
             const [obj_, date] = peer_;
-            return [as("messages.botResults", await this.getTlObject(obj_)), date];
+            return [Api.as("messages.botResults", await this.getTlObject(obj_)), date];
         }
         else {
             return null;
         }
     }
     async setCallbackQueryAnswer(chatId, messageId, question, answer) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.callbackQueryAnswer(chatId, messageId, question), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(serialize(answer)) : answer, new Date()]);
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.callbackQueryAnswer(chatId, messageId, question), [__classPrivateFieldGet(this, _StorageOperations_mustSerialize, "f") ? rleEncode(Api.serializeObject(answer)) : answer, new Date()]);
     }
     async getCallbackQueryAnswer(chatId, messageId, question) {
         const peer_ = await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.callbackQueryAnswer(chatId, messageId, question));
-        if (peer_ != null) {
+        if (peer_ !== null) {
             const [obj_, date] = peer_;
-            return [as("messages.botCallbackAnswer", await this.getTlObject(obj_)), date];
+            return [Api.as("messages.botCallbackAnswer", await this.getTlObject(obj_)), date];
         }
         else {
             return null;
@@ -505,15 +449,38 @@ export class StorageOperations {
         return null;
     }
     assertUser(source) {
-        if (this.accountType != "user") {
-            throw new InputError(`${source}: not user a client`);
+        if (this.isBot) {
+            throw new InputError(`${source}: not a user client`);
         }
     }
     assertBot(source) {
-        if (this.accountType != "bot") {
+        if (!this.isBot) {
             throw new InputError(`${source}: not a bot client`);
         }
     }
+    get isBot() {
+        return this.auth.mustGet().isBot;
+    }
+    async getChannelAccessHash(id) {
+        const peer = await this.peers.get([id]);
+        if (peer?.[0].type === "channel" || peer?.[0].type === "supergroup") {
+            return peer[1];
+        }
+        else {
+            // TODO: get min peer reference
+            return null;
+        }
+    }
+    async getUserAccessHash(id) {
+        const peer = await this.peers.get([id]);
+        if (peer?.[0].type === "private") {
+            return peer[1];
+        }
+        else {
+            // TODO: get min peer reference
+            return null;
+        }
+    }
     async deleteFiles() {
         if (!__classPrivateFieldGet(this, _StorageOperations_supportsFiles, "f")) {
             return;
@@ -560,21 +527,9 @@ export class StorageOperations {
             await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
         }
     }
-    async deletePeers() {
-        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.peers() })) {
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
-        }
-    }
-    async deleteUsernames() {
-        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.usernames() })) {
-            await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
-        }
-    }
     async clear() {
         await Promise.all([
             this.deleteMessages(),
-            this.removeChats(0),
-            this.removeChats(1),
             this.deleteUpdates(),
             this.deleteFiles(),
             this.deleteCustomEmojiDocuments(),
@@ -584,39 +539,79 @@ export class StorageOperations {
             this.deleteFullChats(),
             this.deleteGroupCalls(),
             this.deleteStickerSetNames(),
-            this.deletePeers(),
-            this.deleteUsernames(),
+            this.peers.clear(),
+            this.usernames.clear(),
+            this.translations.clear(),
+            this.deletePollResults(),
+            this.deletePolls(),
+            this.deleteVoiceTranscriptions(),
+            this.deleteVoiceTranscriptionReferences(),
         ]);
     }
-    async setApiId(apiId) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.connection.apiId(), apiId);
-    }
-    async getApiId() {
-        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.connection.apiId());
-    }
     async reset() {
         for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: [] })) {
             await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null);
         }
     }
-    async setMinPeerReference(chatId, senderId, messageId) {
-        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.minPeerReference(senderId, chatId), [{ chatId, messageId }, new Date()]);
+    async setPollResults(pollId, pollResults) {
+        await this.setTlObject(K.cache.pollResult(pollId), pollResults);
+    }
+    async getPollResults(pollId) {
+        return await this.getTlObject(K.cache.pollResult(pollId));
     }
-    async getLastMinPeerReference(senderId) {
-        const references = new Array();
-        for await (const [, reference] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.minPeerReferenceSender(senderId) })) {
-            references.push(reference);
+    async deletePollResults() {
+        const maybePromises = new Array();
+        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.pollResults() })) {
+            maybePromises.push(__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null));
         }
-        return references.sort((a, b) => b[1].getTime() - a[1].getTime())[0]?.[0] ?? null;
+        await Promise.all(maybePromises);
     }
-}
-_StorageOperations_storage = new WeakMap(), _StorageOperations_supportsFiles = new WeakMap(), _StorageOperations_mustSerialize = new WeakMap(), _StorageOperations_authKeyId = new WeakMap(), _StorageOperations_accountId = new WeakMap(), _StorageOperations_accountType = new WeakMap(), _StorageOperations_instances = new WeakSet(), _StorageOperations_resetAuthKeyId = async function _StorageOperations_resetAuthKeyId(authKey) {
-    if (authKey != null) {
-        __classPrivateFieldSet(this, _StorageOperations_authKeyId, bigIntFromBuffer((await sha1(authKey)).subarray(-8), true, false), "f");
+    async setPoll(pollId, poll) {
+        await this.setTlObject(K.cache.poll(pollId), poll);
     }
-    else {
-        __classPrivateFieldSet(this, _StorageOperations_authKeyId, null, "f");
+    async getPoll(pollId) {
+        return await this.getTlObject(K.cache.poll(pollId));
+    }
+    async deletePolls() {
+        const maybePromises = new Array();
+        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.polls() })) {
+            maybePromises.push(__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null));
+        }
+        await Promise.all(maybePromises);
+    }
+    async setVoiceTranscription(voiceTranscription) {
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.voiceTranscription(BigInt(voiceTranscription.id)), voiceTranscription);
+    }
+    async getVoiceTranscription(transcriptionId) {
+        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.voiceTranscription(transcriptionId));
+    }
+    async deleteVoiceTranscriptions() {
+        const maybePromises = new Array();
+        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.voiceTranscriptions() })) {
+            maybePromises.push(__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null));
+        }
+        await Promise.all(maybePromises);
+    }
+    async setVoiceTranscriptionReference(chatId, messageId, messageEditDate, transcriptionId) {
+        await __classPrivateFieldGet(this, _StorageOperations_storage, "f").set(K.cache.voiceTranscriptionReference(chatId, messageId, messageEditDate.getTime()), transcriptionId);
+    }
+    async getVoiceTranscriptionReference(chatId, messageId, messageEditDate) {
+        return await __classPrivateFieldGet(this, _StorageOperations_storage, "f").get(K.cache.voiceTranscriptionReference(chatId, messageId, messageEditDate.getTime()));
+    }
+    async deleteVoiceTranscriptionReferences() {
+        const maybePromises = new Array();
+        for await (const [key] of await __classPrivateFieldGet(this, _StorageOperations_storage, "f").getMany({ prefix: K.cache.voiceTranscriptions() })) {
+            maybePromises.push(__classPrivateFieldGet(this, _StorageOperations_storage, "f").set(key, null));
+        }
+        await Promise.all(maybePromises);
     }
+}
+_StorageOperations_storage = new WeakMap(), _StorageOperations_supportsFiles = new WeakMap(), _StorageOperations_mustSerialize = new WeakMap(), _StorageOperations_L = new WeakMap(), _StorageOperations_maps = new WeakMap(), _StorageOperations_values = new WeakMap(), _StorageOperations_lastCommit = new WeakMap(), _StorageOperations_accountId = new WeakMap(), _StorageOperations_instances = new WeakSet(), _StorageOperations_addMap = function _StorageOperations_addMap(map) {
+    __classPrivateFieldGet(this, _StorageOperations_maps, "f").push(map);
+    return map;
+}, _StorageOperations_addValue = function _StorageOperations_addValue(value) {
+    __classPrivateFieldGet(this, _StorageOperations_values, "f").push(value);
+    return value;
 }, _StorageOperations_getUpdateId = function _StorageOperations_getUpdateId(update) {
     let id = BigInt(Date.now()) << 32n;
     if ("pts" in update && update.pts) {
@@ -627,3 +622,129 @@ _StorageOperations_storage = new WeakMap(), _StorageOperations_supportsFiles = n
     }
     return id;
 };
+class StorageMap {
+    constructor(storage, path) {
+        _StorageMap_storage.set(this, void 0);
+        _StorageMap_path.set(this, void 0);
+        _StorageMap_pendingUpdates.set(this, new Map());
+        _StorageMap_cache.set(this, new LruCache(20_000));
+        __classPrivateFieldSet(this, _StorageMap_storage, storage, "f");
+        __classPrivateFieldSet(this, _StorageMap_path, path, "f");
+    }
+    set(key, value) {
+        const key_ = toString(key);
+        __classPrivateFieldGet(this, _StorageMap_cache, "f").set(key_, value);
+        if (!__classPrivateFieldGet(this, _StorageMap_storage, "f").isMemory) {
+            __classPrivateFieldGet(this, _StorageMap_pendingUpdates, "f").set(key_, value);
+        }
+    }
+    get pendingUpdateCount() {
+        return __classPrivateFieldGet(this, _StorageMap_pendingUpdates, "f").size;
+    }
+    mustGet(key) {
+        const value = __classPrivateFieldGet(this, _StorageMap_cache, "f").get(toString(key));
+        if (value === undefined) {
+            unreachable();
+        }
+        else {
+            return value;
+        }
+    }
+    async clear() {
+        await awaitablePooledMap(10, await __classPrivateFieldGet(this, _StorageMap_storage, "f").getMany({ prefix: [__classPrivateFieldGet(this, _StorageMap_path, "f")] }), async ([key]) => await __classPrivateFieldGet(this, _StorageMap_storage, "f").set(key, null));
+    }
+    async get(key) {
+        const key_ = toString(key);
+        let value = __classPrivateFieldGet(this, _StorageMap_cache, "f").get(key_);
+        if (value === undefined) {
+            value = await __classPrivateFieldGet(this, _StorageMap_storage, "f").get([__classPrivateFieldGet(this, _StorageMap_path, "f"), ...key]);
+            __classPrivateFieldGet(this, _StorageMap_cache, "f").set(key_, value);
+        }
+        return value;
+    }
+    async commit() {
+        if (__classPrivateFieldGet(this, _StorageMap_storage, "f").isMemory) {
+            return;
+        }
+        await awaitablePooledMap(2, __classPrivateFieldGet(this, _StorageMap_pendingUpdates, "f"), async ([key, value]) => await __classPrivateFieldGet(this, _StorageMap_storage, "f").set([__classPrivateFieldGet(this, _StorageMap_path, "f"), ...fromString(key)], value));
+        __classPrivateFieldGet(this, _StorageMap_pendingUpdates, "f").clear();
+    }
+}
+_StorageMap_storage = new WeakMap(), _StorageMap_path = new WeakMap(), _StorageMap_pendingUpdates = new WeakMap(), _StorageMap_cache = new WeakMap();
+class StorageValue {
+    constructor(storage, path) {
+        _StorageValue_storage.set(this, void 0);
+        _StorageValue_key.set(this, void 0);
+        _StorageValue_updatePending.set(this, false);
+        _StorageValue_value.set(this, void 0);
+        __classPrivateFieldSet(this, _StorageValue_storage, storage, "f");
+        __classPrivateFieldSet(this, _StorageValue_key, [path], "f");
+    }
+    set(value) {
+        __classPrivateFieldSet(this, _StorageValue_value, value, "f");
+        if (!__classPrivateFieldGet(this, _StorageValue_storage, "f").isMemory) {
+            __classPrivateFieldSet(this, _StorageValue_updatePending, true, "f");
+        }
+    }
+    get isUpdatePending() {
+        return __classPrivateFieldGet(this, _StorageValue_updatePending, "f");
+    }
+    mustGet() {
+        return __classPrivateFieldGet(this, _StorageValue_value, "f") === undefined ? unreachable() : __classPrivateFieldGet(this, _StorageValue_value, "f");
+    }
+    async get() {
+        if (__classPrivateFieldGet(this, _StorageValue_value, "f") === undefined) {
+            __classPrivateFieldSet(this, _StorageValue_value, await __classPrivateFieldGet(this, _StorageValue_storage, "f").get(__classPrivateFieldGet(this, _StorageValue_key, "f")), "f");
+        }
+        return __classPrivateFieldGet(this, _StorageValue_value, "f");
+    }
+    async commit() {
+        if (__classPrivateFieldGet(this, _StorageValue_storage, "f").isMemory || __classPrivateFieldGet(this, _StorageValue_value, "f") === undefined) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _StorageValue_storage, "f").set(__classPrivateFieldGet(this, _StorageValue_key, "f"), __classPrivateFieldGet(this, _StorageValue_value, "f"));
+        __classPrivateFieldSet(this, _StorageValue_updatePending, false, "f");
+    }
+}
+_StorageValue_storage = new WeakMap(), _StorageValue_key = new WeakMap(), _StorageValue_updatePending = new WeakMap(), _StorageValue_value = new WeakMap();
+class StorageAuth extends StorageValue {
+    constructor(storage) {
+        super(storage, "auth");
+        _StorageAuth_instances.add(this);
+        _StorageAuth_authKeyId.set(this, null);
+    }
+    async get() {
+        const value = await super.get();
+        await __classPrivateFieldGet(this, _StorageAuth_instances, "m", _StorageAuth_resetAuthKeyId).call(this, value);
+        return value;
+    }
+    mustGet() {
+        return super.mustGet() ?? {
+            apiId: 0,
+            authKey: new Uint8Array(),
+            dc: null,
+            isBot: false,
+            userId: 0,
+        };
+    }
+    async set(auth) {
+        super.set(auth);
+        await __classPrivateFieldGet(this, _StorageAuth_instances, "m", _StorageAuth_resetAuthKeyId).call(this, auth);
+    }
+    async update(fn) {
+        const auth = this.mustGet();
+        fn(auth);
+        await this.set(auth);
+    }
+    get authKeyId() {
+        return __classPrivateFieldGet(this, _StorageAuth_authKeyId, "f");
+    }
+}
+_StorageAuth_authKeyId = new WeakMap(), _StorageAuth_instances = new WeakSet(), _StorageAuth_resetAuthKeyId = async function _StorageAuth_resetAuthKeyId(auth) {
+    if (auth?.authKey) {
+        __classPrivateFieldSet(this, _StorageAuth_authKeyId, intFromBytes((await sha1(auth.authKey)).subarray(-8)), "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _StorageAuth_authKeyId, null, "f");
+    }
+};