@mtkruto/node 0.0.999 → 0.1.100

package/esm/4_constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 161;
-export declare const APP_VERSION = "MTKruto 0.0.999";
+export declare const APP_VERSION = "MTKruto 0.1.100";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -54,7 +54,7 @@ export const PUBLIC_KEYS = Object.freeze([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2-test";
 export const LAYER = 161;
-export const APP_VERSION = "MTKruto 0.0.999";
+export const APP_VERSION = "MTKruto 0.1.100";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/4_errors.d.ts

@@ -0,0 +1,25 @@
+import { types } from "./2_tl.js";
+export * from "./3_errors.js";
+export declare class FloodWait extends types.RPCError {
+    seconds: number;
+    constructor(params: {
+        errorCode: number;
+        errorMessage: string;
+    });
+}
+export declare class Migrate extends types.RPCError {
+    dc: number;
+    constructor(params: {
+        errorCode: number;
+        errorMessage: string;
+    });
+}
+export declare class UserMigrate extends Migrate {
+}
+export declare class PhoneMigrate extends Migrate {
+}
+export declare class FileMigrate extends Migrate {
+}
+export declare class StatsMigrate extends Migrate {
+}
+export declare function upgradeInstance(error: types.RPCError): types.RPCError;

package/esm/4_errors.js

@@ -0,0 +1,64 @@
+import { UNREACHABLE } from "./1_utilities.js";
+import { map } from "./3_errors.js";
+import { types } from "./2_tl.js";
+export * from "./3_errors.js";
+export class FloodWait extends types.RPCError {
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const p = params.errorMessage.split("_");
+        this.seconds = Number(p[p.length - 1]);
+        if (isNaN(this.seconds)) {
+            UNREACHABLE();
+        }
+    }
+}
+export class Migrate extends types.RPCError {
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "dc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const p = params.errorMessage.split("_");
+        this.dc = Number(p[p.length - 1]);
+        if (isNaN(this.dc)) {
+            UNREACHABLE();
+        }
+    }
+}
+export class UserMigrate extends Migrate {
+}
+export class PhoneMigrate extends Migrate {
+}
+export class FileMigrate extends Migrate {
+}
+export class StatsMigrate extends Migrate {
+}
+const prefixMap = {
+    "FILE_MIGRATE_": FileMigrate,
+    "PHONE_MIGRATE_": PhoneMigrate,
+    "USER_MIGRATE_": UserMigrate,
+    "STATS_MIGRATE_": StatsMigrate,
+    "FLOOD_WAIT_": FloodWait,
+};
+export function upgradeInstance(error) {
+    for (const [k, v] of Object.entries(prefixMap)) {
+        if (error.errorMessage.startsWith(k)) {
+            return new v(error);
+        }
+    }
+    for (const [k, v] of Object.entries(map)) {
+        if (error.errorMessage == k) {
+            return new v(error);
+        }
+    }
+    return error;
+}

package/esm/client/2_client_plain.js

@@ -2,8 +2,8 @@ import { assertEquals, assertInstanceOf, debug, factorize, ige256Decrypt, ige256
 import { bigIntFromBuffer, bufferFromBigInt, concat, getRandomBigInt, modExp, rsaPad, sha1, UNREACHABLE } from "../1_utilities.js";
 import { functions, serialize, TLReader, types } from "../2_tl.js";
 import { PUBLIC_KEYS } from "../4_constants.js";
-import { ClientAbstract } from "./1_client_abstract.js";
 import { getMessageId, packUnencryptedMessage, unpackUnencryptedMessage } from "./0_message.js";
+import { ClientAbstract } from "./1_client_abstract.js";
 const d = debug("ClientPlain/createAuthKey");
 export class ClientPlain extends ClientAbstract {
     constructor(params) {

package/esm/client/4_client.d.ts

@@ -3,6 +3,7 @@ import { functions, ReadObject, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
 import { BotCommand, BotCommandScope, ChatAction, ChatID, InlineQueryResult, InlineQueryResultButton, Message } from "../3_types.js";
+import { Migrate } from "../4_errors.js";
 import { With } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
 import { AnswerCallbackQueryParams, AuthorizeUserParams, ClientParams, EditMessageParams, FilterableUpdates, FilterUpdate, ForwardMessagesParams, Handler, ParseMode, SendMessagesParams, SendPollParams, Update } from "./3_types.js";
@@ -60,7 +61,7 @@ export declare class Client extends ClientAbstract {
     private assertUser;
     private assertBot;
     private fetchState;
-    [handleMigrationError](err: types.RPCError): Promise<void>;
+    [handleMigrationError](err: Migrate): Promise<void>;
     private connectionInited;
     disconnect(): Promise<void>;
     private initConnection;

package/esm/client/4_client.js

@@ -4,12 +4,13 @@ import { as, functions, getChannelChatId, Message_, MessageContainer, peerToChat
 import { StorageMemory } from "../3_storage.js";
 import { botCommandScopeToTlObject, constructCallbackQuery, constructInlineQuery, constructMessage, constructUser, FileID, FileType, inlineQueryResultToTlObject, messageEntityToTlObject, replyMarkupToTlObject, ThumbnailSource } from "../3_types.js";
 import { ACK_THRESHOLD, APP_VERSION, CHANNEL_DIFFERENCE_LIMIT_BOT, CHANNEL_DIFFERENCE_LIMIT_USER, DEVICE_MODEL, LANG_CODE, LANG_PACK, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, STICKER_SET_NAME_TTL, SYSTEM_LANG_CODE, SYSTEM_VERSION, USERNAME_TTL, ZERO_CHANNEL_ID } from "../4_constants.js";
-import { isChannelPtsUpdate, isPtsUpdate, resolve } from "./0_utilities.js";
+import { AuthKeyUnregistered, Migrate, PasswordHashInvalid, PhoneNumberInvalid, SessionPasswordNeeded, upgradeInstance } from "../4_errors.js";
+import { parseHtml } from "./0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "./0_message.js";
 import { checkPassword } from "./0_password.js";
-import { parseHtml } from "./0_html.js";
-import { ClientPlain } from "./2_client_plain.js";
+import { isChannelPtsUpdate, isPtsUpdate, resolve } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
+import { ClientPlain } from "./2_client_plain.js";
 import { skip } from "./3_types.js";
 const d = debug("Client");
 const dGap = debug("Client/recoverUpdateGap");
@@ -327,18 +328,12 @@ export class Client extends ClientAbstract {
         d("state fetched [%s]", source);
     }
     async [handleMigrationError](err) {
-        const match = err.errorMessage.match(/MIGRATE_(\d)$/);
-        if (match) {
-            let newDc = match[1];
-            if (Math.abs(this.dcId) >= 10000) {
-                newDc += "-test";
-            }
-            await this.reconnect(newDc);
-            d("migrated to DC%s", newDc);
-        }
-        else {
-            UNREACHABLE();
+        let newDc = String(err.dc);
+        if (Math.abs(this.dcId) >= 10000) {
+            newDc += "-test";
         }
+        await this.reconnect(newDc);
+        d("migrated to DC%s", newDc);
     }
     disconnect() {
         this.connectionInited = false;
@@ -411,7 +406,7 @@ export class Client extends ClientAbstract {
             return;
         }
         catch (err) {
-            if (!(err instanceof types.RPCError) || err.errorMessage != "AUTH_KEY_UNREGISTERED") {
+            if (!(err instanceof AuthKeyUnregistered)) {
                 throw err;
             }
         }
@@ -423,16 +418,10 @@ export class Client extends ClientAbstract {
                     break;
                 }
                 catch (err) {
-                    if (err instanceof types.RPCError) {
-                        const match = err.errorMessage.match(/MIGRATE_(\d)$/);
-                        if (match) {
-                            await this[handleMigrationError](err);
-                            await this.initConnection();
-                            continue;
-                        }
-                        else {
-                            throw err;
-                        }
+                    if (err instanceof Migrate) {
+                        await this[handleMigrationError](err);
+                        await this.initConnection();
+                        continue;
                     }
                     else {
                         throw err;
@@ -464,16 +453,10 @@ export class Client extends ClientAbstract {
                     sentCode = await sendCode();
                 }
                 catch (err) {
-                    if (err instanceof types.RPCError) {
-                        const match = err.errorMessage.match(/MIGRATE_(\d)$/);
-                        if (match) {
-                            await this[handleMigrationError](err);
-                            await this.initConnection();
-                            sentCode = await sendCode();
-                        }
-                        else {
-                            throw err;
-                        }
+                    if (err instanceof Migrate) {
+                        await this[handleMigrationError](err);
+                        await this.initConnection();
+                        sentCode = await sendCode();
                     }
                     else {
                         throw err;
@@ -482,7 +465,7 @@ export class Client extends ClientAbstract {
                 break;
             }
             catch (err) {
-                if (err instanceof types.RPCError && err.errorMessage == "PHONE_NUMBER_INVALID") {
+                if (err instanceof PhoneNumberInvalid) {
                     continue;
                 }
                 else {
@@ -516,7 +499,7 @@ export class Client extends ClientAbstract {
                 }
             }
         }
-        if (!(err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED")) {
+        if (!(err instanceof SessionPasswordNeeded)) {
             throw err;
         }
         while (true) {
@@ -535,7 +518,7 @@ export class Client extends ClientAbstract {
                 break;
             }
             catch (err) {
-                if (err instanceof types.RPCError && err.errorMessage == "PASSWORD_HASH_INVALID") {
+                if (err instanceof PasswordHashInvalid) {
                     continue;
                 }
                 else {
@@ -557,7 +540,7 @@ export class Client extends ClientAbstract {
             return;
         }
         catch (err) {
-            if (!(err instanceof types.RPCError) || err.errorMessage != "AUTH_KEY_UNREGISTERED") {
+            if (!(err instanceof AuthKeyUnregistered)) {
                 throw err;
             }
         }
@@ -609,7 +592,7 @@ export class Client extends ClientAbstract {
                             const promise = this.promises.get(messageId);
                             if (promise) {
                                 if (result instanceof types.RPCError) {
-                                    promise.reject(result);
+                                    promise.reject(upgradeInstance(result));
                                 }
                                 else {
                                     promise.resolve(result);
@@ -703,7 +686,7 @@ export class Client extends ClientAbstract {
             });
         }
         catch (err) {
-            if (err instanceof types.RPCError && err.errorMessage == "AUTH_KEY_UNREGISTERED") {
+            if (err instanceof AuthKeyUnregistered) {
                 await this.propagateAuthorizationState(false);
             }
             throw err;

package/esm/deps/deno.land/x/{tgcrypto@0.1.3 → tgcrypto@0.3.2}/mod.d.ts

@@ -16,18 +16,14 @@ export declare function ige256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uin
  */
 export declare function ige256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
 /**
- * Performs CTR-256 encryption.
+ * Performs CTR-256 encryption/decryption.
  *
  * @param data The data, larger than a byte
  * @param key 32-byte encryption key
  * @param iv 16-byte initialization vector
  * @param state 1-byte state
  */
-export declare function ctr256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array, Uint8Array];
-/**
- * Alias of `ctr256Encrypt`
- */
-export declare function ctr256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array, Uint8Array];
+export declare function ctr256(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): void;
 /**
  * Performs CBC-256 encryption.
  *

package/esm/deps/deno.land/x/tgcrypto@0.3.2/mod.js

@@ -0,0 +1,158 @@
+import { default as init_ } from "./tgcrypto.js";
+// deno-lint-ignore no-explicit-any
+let module_;
+const promise = init_().then((v) => module_ = v);
+export async function init() {
+    await promise;
+}
+function checkIgeParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 32) {
+        throw new TypeError("iv must be 32 bytes");
+    }
+}
+/**
+ * Performs IGE-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+export function ige256Encrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(1024);
+    module_.ccall("ige256_encrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+    }
+}
+/**
+ * Performs IGE-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+export function ige256Decrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(1024);
+    module_.ccall("ige256_decrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+    }
+}
+function checkCtrParams(data, key, iv, state) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+    else if (state.length != 1) {
+        throw new TypeError("state must be 1 byte");
+    }
+}
+/**
+ * Performs CTR-256 encryption/decryption.
+ *
+ * @param data The data, larger than a byte
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ * @param state 1-byte state
+ */
+export function ctr256(data, key, iv, state) {
+    checkCtrParams(data, key, iv, state);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    const ivp = module_._malloc(iv.length);
+    module_.HEAPU8.set(iv, ivp);
+    const statep = module_._malloc(state.length);
+    module_.HEAPU8.set(state, statep);
+    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.length, key, ivp, statep]);
+    data.set(module_.HEAPU8.slice(datap, datap + data.length));
+    iv.set(module_.HEAPU8.slice(ivp, ivp + iv.length));
+    state.set(module_.HEAPU8.slice(statep, statep + state.length));
+    module_._free(datap);
+    module_._free(ivp);
+    module_._free(statep);
+}
+function checkCbcParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+}
+/**
+ * Performs CBC-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+export function cbc256Encrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+/**
+ * Performs CBC-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+export function cbc256Decrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+export function factorize(pq) {
+    const pqp = module_._malloc(16);
+    module_.ccall("factorize", "void", ["number", "pointer"], [pq, pqp]);
+    try {
+        const pqp_ = module_.HEAP64.slice(pqp / 8, pqp / 8 + 2);
+        return [pqp_[0], pqp_[1]];
+    }
+    finally {
+        module_._free(pqp);
+    }
+}

package/esm/deps/deno.land/x/tgcrypto@0.3.2/tgcrypto.d.ts

@@ -0,0 +1,2 @@
+export default Module;
+declare function Module(moduleArg?: {}): any;