@mtcute/convert 0.17.0 → 0.18.0-rc.5

package/package.json

@@ -1,11 +1,21 @@
 {
     "name": "@mtcute/convert",
     "type": "module",
-    "version": "0.17.0",
+    "version": "0.18.0-rc.5",
     "description": "Cross-library session conversion utilities",
-    "author": "alina sireneva <alina@tei.su>",
     "license": "MIT",
-    "sideEffects": false,
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@mtcute/core": "0.18.0-rc.5",
+        "@fuman/utils": "0.0.3",
+        "@fuman/net": "0.0.3",
+        "@fuman/io": "0.0.3"
+    },
     "exports": {
         ".": {
             "import": {
@@ -18,13 +28,6 @@
             }
         }
     },
-    "scripts": {},
-    "dependencies": {
-        "@mtcute/core": "^0.17.0"
-    },
-    "homepage": "https://mtcute.dev",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/mtcute/mtcute"
-    }
+    "author": "alina sireneva <alina@tei.su>",
+    "sideEffects": false
 }

package/tdesktop/convert.d.ts

@@ -0,0 +1,5 @@
+import { MaybeArray } from '@fuman/utils';
+import { TdataOptions, Tdata } from './tdata.js';
+import { StringSessionData } from '@mtcute/core/utils.js';
+export declare function convertFromTdata(tdata: Tdata | TdataOptions, accountIdx?: number): Promise<StringSessionData>;
+export declare function convertToTdata(sessions: MaybeArray<StringSessionData | string>, tdata: Tdata | TdataOptions): Promise<void>;

package/tdesktop/index.d.ts

@@ -0,0 +1,5 @@
+import * as qt from './qt-bundle.js';
+export { qt };
+export * from './convert.js';
+export * from './tdata.js';
+export * from './types.js';

package/tdesktop/qt-bundle.d.ts

@@ -0,0 +1,3 @@
+import * as read from './qt-reader.js';
+import * as write from './qt-writer.js';
+export { read, write };

package/tdesktop/qt-reader.d.ts

@@ -0,0 +1,6 @@
+import { ISyncReadable } from '@fuman/io';
+import { Long } from '@mtcute/core';
+export declare function readQByteArray(readable: ISyncReadable): Uint8Array;
+export declare function readLong(readable: ISyncReadable): Long;
+export declare function readCharArray(readable: ISyncReadable): Uint8Array;
+export declare function readQString(readable: ISyncReadable): string;

package/tdesktop/qt-writer.d.ts

@@ -0,0 +1,6 @@
+import { ISyncWritable } from '@fuman/io';
+import { Long } from '@mtcute/core';
+export declare function writeQByteArray(into: ISyncWritable, buf: Uint8Array): void;
+export declare function writeLong(into: ISyncWritable, long: Long): void;
+export declare function writeCharArray(into: ISyncWritable, buf: Uint8Array): void;
+export declare function writeQString(into: ISyncWritable, str: string): void;

package/tdesktop/tdata.d.ts

@@ -0,0 +1,65 @@
+import { INodeFsLike } from '../utils/fs.js';
+import { InputTdKeyData, TdKeyData, TdMtpAuthorization } from './types.js';
+import { IExtendedCryptoProvider } from '../utils/crypto.js';
+export interface TdataOptions {
+    /** Full path to the tdata directory */
+    path: string;
+    /**
+     * File system to use for reading/writing.
+     *
+     * @default  `import('node:fs/promises')`
+     */
+    fs?: INodeFsLike;
+    /**
+     * Crypto functions to use for encryption/decryption.
+     *
+     * @default  `node:crypto`-based implementation
+     */
+    crypto?: IExtendedCryptoProvider;
+    /**
+     * Whether to ignore TDF version mismatch.
+     * If set to `true`, the version will be ignored and the file will be read as is,
+     * however the probability of errors is higher.
+     */
+    ignoreVersion?: boolean;
+    /**
+     * Whether the host machine has LE processor (default true, try changing in case of errors)
+     */
+    le?: boolean;
+    /**
+     * Value of -key cli parameter.
+     * Defaults to `data`
+     */
+    dataKey?: string;
+    /**
+     * Local passcode
+     */
+    passcode?: string;
+}
+export declare class Tdata {
+    #private;
+    readonly options: TdataOptions;
+    readonly fs: INodeFsLike;
+    readonly crypto: IExtendedCryptoProvider;
+    private constructor();
+    readonly keyData: TdKeyData;
+    static open(options: TdataOptions): Promise<Tdata>;
+    static create(options: TdataOptions & {
+        keyData: InputTdKeyData;
+    }): Promise<Tdata>;
+    getDataName(idx: number): string;
+    readFile(filename: string): Promise<[number, Uint8Array]>;
+    writeFile(filename: string, data: Uint8Array, mkdir?: boolean): Promise<void>;
+    createLocalKey(salt: Uint8Array, passcode?: string): Promise<Uint8Array>;
+    decryptLocal(encrypted: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    encryptLocal(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    readKeyData(): Promise<TdKeyData>;
+    writeKeyData(keyData: TdKeyData): Promise<void>;
+    computeDataNameKey(accountIdx: number): Promise<Uint8Array>;
+    computeDataNameKeyHex(accountIdx: number): Promise<string>;
+    readEncryptedFile(filename: string): Promise<[number, Uint8Array]>;
+    writeEncryptedFile(filename: string, data: Uint8Array, mkdir?: boolean): Promise<void>;
+    readMtpAuthorization(accountIdx?: number): Promise<TdMtpAuthorization>;
+    writeMtpAuthorization(auth: TdMtpAuthorization, accountIdx?: number): Promise<void>;
+    writeEmptyMapFile(accountIdx: number): Promise<void>;
+}

package/tdesktop/tdata.test.d.ts

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

package/tdesktop/types.d.ts

@@ -0,0 +1,22 @@
+import { Long } from '@mtcute/core';
+export interface TdAuthKey {
+    dcId: number;
+    key: Uint8Array;
+}
+export interface TdMtpAuthorization {
+    userId: Long;
+    mainDcId: number;
+    authKeys: TdAuthKey[];
+    authKeysToDestroy: TdAuthKey[];
+}
+export interface InputTdKeyData {
+    localKey?: Uint8Array;
+    version?: number;
+    count: number;
+    order: number[];
+    active: number;
+}
+export interface TdKeyData extends InputTdKeyData {
+    version: number;
+    localKey: Uint8Array;
+}

package/utils/crypto.d.ts

@@ -0,0 +1,9 @@
+import { MaybePromise } from '@fuman/utils';
+import { ICryptoProvider } from '@mtcute/core/utils.js';
+export interface IExtendedCryptoProvider extends ICryptoProvider {
+    createHash(algorithm: 'md5' | 'sha512'): MaybePromise<{
+        update(data: Uint8Array): MaybePromise<void>;
+        digest(): MaybePromise<Uint8Array>;
+    }>;
+}
+export declare function getDefaultCryptoProvider(): Promise<IExtendedCryptoProvider>;

package/utils/fs.d.ts

@@ -0,0 +1,11 @@
+export interface INodeFsLike {
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    stat(path: string): Promise<{
+        size: number;
+        lastModified: number;
+    }>;
+}

package/wasm/src/index.cjs

@@ -0,0 +1,64 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let wasm;
+let sharedKeyPtr;
+let sharedIvPtr;
+let cachedUint8Memory = null;
+function initCommon() {
+  wasm.libdeflate_alloc_compressor(6);
+  wasm.libdeflate_alloc_decompressor();
+  wasm.__get_shared_out();
+  sharedKeyPtr = wasm.__get_shared_key_buffer();
+  sharedIvPtr = wasm.__get_shared_iv_buffer();
+}
+function getUint8Memory() {
+  if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
+    cachedUint8Memory = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8Memory;
+}
+function initSync(module2) {
+  if (wasm !== void 0) return;
+  if (!(module2 instanceof WebAssembly.Instance)) {
+    if (!(module2 instanceof WebAssembly.Module)) {
+      module2 = new WebAssembly.Module(module2);
+    }
+    module2 = new WebAssembly.Instance(module2);
+  }
+  wasm = module2.exports;
+  initCommon();
+}
+function ige256Encrypt(data, key, iv) {
+  const ptr = wasm.__malloc(data.length + data.length);
+  const inputPtr = ptr;
+  const outputPtr = inputPtr + data.length;
+  const mem = getUint8Memory();
+  mem.set(data, inputPtr);
+  mem.set(key, sharedKeyPtr);
+  mem.set(iv, sharedIvPtr);
+  wasm.ige256_encrypt(inputPtr, data.length, outputPtr);
+  const result = mem.slice(outputPtr, outputPtr + data.length);
+  wasm.__free(ptr);
+  return result;
+}
+function ige256Decrypt(data, key, iv) {
+  const ptr = wasm.__malloc(data.length + data.length);
+  const inputPtr = ptr;
+  const outputPtr = inputPtr + data.length;
+  const mem = getUint8Memory();
+  mem.set(data, inputPtr);
+  mem.set(key, sharedKeyPtr);
+  mem.set(iv, sharedIvPtr);
+  wasm.ige256_decrypt(inputPtr, data.length, outputPtr);
+  const result = mem.slice(outputPtr, outputPtr + data.length);
+  wasm.__free(ptr);
+  return result;
+}
+exports.ige256Decrypt = ige256Decrypt;
+exports.ige256Encrypt = ige256Encrypt;
+exports.initSync = initSync;

package/wasm/src/index.js

@@ -0,0 +1,59 @@
+let wasm;
+let sharedKeyPtr;
+let sharedIvPtr;
+let cachedUint8Memory = null;
+function initCommon() {
+  wasm.libdeflate_alloc_compressor(6);
+  wasm.libdeflate_alloc_decompressor();
+  wasm.__get_shared_out();
+  sharedKeyPtr = wasm.__get_shared_key_buffer();
+  sharedIvPtr = wasm.__get_shared_iv_buffer();
+}
+function getUint8Memory() {
+  if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
+    cachedUint8Memory = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8Memory;
+}
+function initSync(module) {
+  if (wasm !== void 0) return;
+  if (!(module instanceof WebAssembly.Instance)) {
+    if (!(module instanceof WebAssembly.Module)) {
+      module = new WebAssembly.Module(module);
+    }
+    module = new WebAssembly.Instance(module);
+  }
+  wasm = module.exports;
+  initCommon();
+}
+function ige256Encrypt(data, key, iv) {
+  const ptr = wasm.__malloc(data.length + data.length);
+  const inputPtr = ptr;
+  const outputPtr = inputPtr + data.length;
+  const mem = getUint8Memory();
+  mem.set(data, inputPtr);
+  mem.set(key, sharedKeyPtr);
+  mem.set(iv, sharedIvPtr);
+  wasm.ige256_encrypt(inputPtr, data.length, outputPtr);
+  const result = mem.slice(outputPtr, outputPtr + data.length);
+  wasm.__free(ptr);
+  return result;
+}
+function ige256Decrypt(data, key, iv) {
+  const ptr = wasm.__malloc(data.length + data.length);
+  const inputPtr = ptr;
+  const outputPtr = inputPtr + data.length;
+  const mem = getUint8Memory();
+  mem.set(data, inputPtr);
+  mem.set(key, sharedKeyPtr);
+  mem.set(iv, sharedIvPtr);
+  wasm.ige256_decrypt(inputPtr, data.length, outputPtr);
+  const result = mem.slice(outputPtr, outputPtr + data.length);
+  wasm.__free(ptr);
+  return result;
+}
+export {
+  ige256Decrypt,
+  ige256Encrypt,
+  initSync
+};

package/index.d.cts

@@ -1,5 +0,0 @@
-export * from './dcs.js';
-export * from './gramjs/index.js';
-export * from './mtkruto/index.js';
-export * from './pyrogram/index.js';
-export * from './telethon/index.js';

package/utils/ip.d.ts

@@ -1,3 +0,0 @@
-export declare function parseIpFromBytes(data: Uint8Array): string;
-export declare function serializeIpv4ToBytes(ip: string, buf: Uint8Array): void;
-export declare function serializeIpv6ToBytes(ip: string, buf: Uint8Array): void;