@mtcute/core 0.16.7 → 0.16.9

package/storage/storage.d.ts

@@ -0,0 +1,52 @@
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { Logger } from '../utils/logger.js';
+import { IMtStorageProvider } from './provider.js';
+import { AuthKeysService } from './service/auth-keys.js';
+import { DefaultDcsService } from './service/default-dcs.js';
+import { FutureSaltsService } from './service/future-salts.js';
+import { IStorageDriver } from './driver.js';
+interface StorageManagerOptions {
+    provider: IMtStorageProvider;
+    log: Logger;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+}
+/**
+ * Additional options for {@link StorageManager}, that
+ * can be customized by the user.
+ *
+ * @internal
+ */
+export interface StorageManagerExtraOptions {
+    /**
+     * Interval in milliseconds for saving the storage.
+     *
+     * When saving, the storage is expected to persist
+     * all changes to disk, so that they are not lost.
+     */
+    saveInterval?: number;
+    /**
+     * Whether to finalize database before exiting.
+     *
+     * @default  `true`
+     */
+    cleanup?: boolean;
+}
+export declare class StorageManager {
+    readonly options: StorageManagerOptions & StorageManagerExtraOptions;
+    readonly provider: IMtStorageProvider;
+    readonly driver: IStorageDriver;
+    readonly log: Logger;
+    readonly dcs: DefaultDcsService;
+    readonly salts: FutureSaltsService;
+    readonly keys: AuthKeysService;
+    constructor(options: StorageManagerOptions & StorageManagerExtraOptions);
+    private _cleanupRestore?;
+    private _load;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    clear(withAuthKeys?: boolean): Promise<void>;
+    private _destroy;
+    destroy(): Promise<void>;
+}
+export {};

package/utils/async-lock.test.d.ts

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

package/utils/bigint-utils.d.ts

@@ -0,0 +1,47 @@
+import { ICryptoProvider } from './crypto/abstract.js';
+/**
+ * Get the minimum number of bits required to represent a number
+ */
+export declare function bigIntBitLength(n: bigint): number;
+/**
+ * Convert a big integer to a buffer
+ *
+ * @param value  Value to convert
+ * @param length  Length of the resulting buffer (by default it's the minimum required)
+ * @param le  Whether to use little-endian encoding
+ */
+export declare function bigIntToBuffer(value: bigint, length?: number, le?: boolean): Uint8Array;
+/**
+ * Convert a buffer to a big integer
+ *
+ * @param buffer  Buffer to convert
+ * @param le  Whether to use little-endian encoding
+ */
+export declare function bufferToBigInt(buffer: Uint8Array, le?: boolean): bigint;
+/**
+ * Generate a cryptographically safe random big integer of the given size (in bytes)
+ * @param size  Size in bytes
+ */
+export declare function randomBigInt(crypto: ICryptoProvider, size: number): bigint;
+/**
+ * Generate a random big integer of the given size (in bits)
+ * @param bits
+ */
+export declare function randomBigIntBits(crypto: ICryptoProvider, bits: number): bigint;
+/**
+ * Generate a random big integer in the range [min, max)
+ *
+ * @param max  Maximum value (exclusive)
+ * @param min  Minimum value (inclusive)
+ */
+export declare function randomBigIntInRange(crypto: ICryptoProvider, max: bigint, min?: bigint): bigint;
+/**
+ * Compute the multiplicity of 2 in the prime factorization of n
+ * @param n
+ */
+export declare function twoMultiplicity(n: bigint): bigint;
+export declare function bigIntMin(a: bigint, b: bigint): bigint;
+export declare function bigIntAbs(a: bigint): bigint;
+export declare function bigIntGcd(a: bigint, b: bigint): bigint;
+export declare function bigIntModPow(base: bigint, exp: bigint, mod: bigint): bigint;
+export declare function bigIntModInv(a: bigint, n: bigint): bigint;

package/utils/bigint-utils.test.d.ts

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

package/utils/buffer-utils.test.d.ts

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

package/utils/composer.test.d.ts

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

package/utils/condition-variable.test.d.ts

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

package/utils/controllable-promise.test.d.ts

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

package/utils/crypto/abstract.d.ts

@@ -0,0 +1,29 @@
+import { MaybePromise } from '../../types/index.js';
+export interface IEncryptionScheme {
+    encrypt: (data: Uint8Array) => Uint8Array;
+    decrypt: (data: Uint8Array) => Uint8Array;
+}
+export interface IAesCtr {
+    process: (data: Uint8Array) => Uint8Array;
+    close?: () => void;
+}
+export interface ICryptoProvider {
+    initialize?: () => MaybePromise<void>;
+    sha1: (data: Uint8Array) => Uint8Array;
+    sha256: (data: Uint8Array) => Uint8Array;
+    pbkdf2: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen?: number, // = 64
+    algo?: string) => MaybePromise<Uint8Array>;
+    hmacSha256: (data: Uint8Array, key: Uint8Array) => MaybePromise<Uint8Array>;
+    createAesCtr: (key: Uint8Array, iv: Uint8Array, encrypt: boolean) => IAesCtr;
+    createAesIge: (key: Uint8Array, iv: Uint8Array) => IEncryptionScheme;
+    factorizePQ: (pq: Uint8Array) => MaybePromise<[Uint8Array, Uint8Array]>;
+    gzip: (data: Uint8Array, maxSize: number) => Uint8Array | null;
+    gunzip: (data: Uint8Array) => Uint8Array;
+    randomFill: (buf: Uint8Array) => void;
+    randomBytes: (size: number) => Uint8Array;
+}
+export declare abstract class BaseCryptoProvider {
+    abstract randomFill(buf: Uint8Array): void;
+    factorizePQ(pq: Uint8Array): [Uint8Array, Uint8Array];
+    randomBytes(size: number): Uint8Array;
+}

package/utils/crypto/factorization.d.ts

@@ -0,0 +1,6 @@
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Factorize `p*q` to `p` and `q` synchronously using Brent-Pollard rho algorithm
+ * @param pq
+ */
+export declare function factorizePQSync(crypto: ICryptoProvider, pq: Uint8Array): [Uint8Array, Uint8Array];

package/utils/crypto/factorization.test.d.ts

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

package/utils/crypto/keys.d.ts

@@ -0,0 +1,27 @@
+import { default as Long } from 'long';
+import { TlPublicKey } from '@mtcute/tl/binary/rsa-keys.js';
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Parse PEM-encoded RSA public key information into modulus and exponent
+ * and compute its fingerprint as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param key  PEM-encoded RSA public key
+ * @param old  Whether this is an "old" key
+ */
+export declare function parsePublicKey(crypto: ICryptoProvider, key: string, old?: boolean): TlPublicKey;
+/**
+ * Add public key to the global index.
+ *
+ * @param crypto  Crypto provider
+ * @param key  PEM-encoded RSA public key
+ * @param old  Whether this is an "old" key
+ */
+export declare function addPublicKey(crypto: ICryptoProvider, key: string, old?: boolean): void;
+/**
+ * Get public key by its fingerprint.
+ *
+ * @param fingerprints  Fingerprints to match. The first one to match is returned.
+ * @param allowOld  Whether to allow "old" keys
+ */
+export declare function findKeyByFingerprints(fingerprints: (string | Long)[], allowOld?: boolean): TlPublicKey | null;

package/utils/crypto/keys.test.d.ts

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

package/utils/crypto/miller-rabin.d.ts

@@ -0,0 +1,2 @@
+import { ICryptoProvider } from './abstract.js';
+export declare function millerRabin(crypto: ICryptoProvider, n: bigint, rounds?: number): boolean;

package/utils/crypto/miller-rabin.test.d.ts

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

package/utils/crypto/mtproto.d.ts

@@ -0,0 +1,31 @@
+import { ICryptoProvider, IEncryptionScheme } from './abstract.js';
+/**
+ * Generate AES key and IV from nonces as defined by MTProto.
+ * Used in authorization flow.
+ *
+ * @param crypto  Crypto provider
+ * @param serverNonce  Server nonce
+ * @param newNonce  New nonce
+ * @returns  Tuple: `[key, iv]`
+ */
+export declare function generateKeyAndIvFromNonce(crypto: ICryptoProvider, serverNonce: Uint8Array, newNonce: Uint8Array): [Uint8Array, Uint8Array];
+/**
+ * Create AES IGE instance for message (given auth key and message key)
+ * as defined by MTProto v2.
+ *
+ * @param crypto  Crypto provider
+ * @param authKey  Authorization key
+ * @param messageKey  Message key
+ * @param client  Whether this is a client to server message
+ */
+export declare function createAesIgeForMessage(crypto: ICryptoProvider, authKey: Uint8Array, messageKey: Uint8Array, client: boolean): IEncryptionScheme;
+/**
+ * Create AES IGE instance for file (given auth key and message key)
+ * as defined by MTProto v1.
+ *
+ * @param crypto  Crypto provider
+ * @param authKey  Authorization key
+ * @param messageKey  Message key
+ * @param client  Whether this is a client to server message
+ */
+export declare function createAesIgeForMessageOld(crypto: ICryptoProvider, authKey: Uint8Array, messageKey: Uint8Array, client: boolean): IEncryptionScheme;

package/utils/crypto/mtproto.test.d.ts

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

package/utils/crypto/password.d.ts

@@ -0,0 +1,29 @@
+import { tl } from '@mtcute/tl';
+import { ICryptoProvider } from './abstract.js';
+/**
+ * Compute password hash as defined by MTProto.
+ *
+ * See https://core.telegram.org/api/srp#checking-the-password-with-srp
+ *
+ * @param crypto  Crypto provider
+ * @param password  Password
+ * @param salt1  Salt 1
+ * @param salt2  Salt 2
+ */
+export declare function computePasswordHash(crypto: ICryptoProvider, password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array): Promise<Uint8Array>;
+/**
+ * Compute new password SRP hash as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param algo  KDF algorithm
+ * @param password  Password
+ */
+export declare function computeNewPasswordHash(crypto: ICryptoProvider, algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+/**
+ * Compute SRP check parameters for 2fa password as defined by MTProto.
+ *
+ * @param crypto  Crypto provider
+ * @param request  SRP request
+ * @param password  2fa password
+ */
+export declare function computeSrpParams(crypto: ICryptoProvider, request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;

package/utils/crypto/password.test.d.ts

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

package/utils/crypto/utils.test.d.ts

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

package/utils/deque.test.d.ts

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

package/utils/error-reporting.d.ts

@@ -0,0 +1,3 @@
+import { tl } from '@mtcute/tl';
+import { Logger } from './logger.js';
+export declare function reportUnknownError(log: Logger, error: tl.RpcError, method: string): void;

package/utils/function-utils.test.d.ts

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

package/utils/index.d.ts

@@ -0,0 +1,30 @@
+import * as timers from './timers.js';
+export * from '../highlevel/utils/index.js';
+export * from '../highlevel/storage/service/current-user.js';
+export * from '../highlevel/storage/service/updates.js';
+export * from '../storage/service/base.js';
+export * from '../storage/service/default-dcs.js';
+export * from './async-lock.js';
+export * from './bigint-utils.js';
+export * from './buffer-utils.js';
+export * from './composer.js';
+export * from './condition-variable.js';
+export * from './controllable-promise.js';
+export * from './crypto/index.js';
+export * from './dcs.js';
+export * from './deque.js';
+export * from './early-timer.js';
+export * from './function-utils.js';
+export * from './linked-list.js';
+export * from './links/index.js';
+export * from './logger.js';
+export * from './long-utils.js';
+export * from './lru-map.js';
+export * from './lru-set.js';
+export * from './misc-utils.js';
+export * from './peer-utils.js';
+export * from './sorted-array.js';
+export * from './tl-json.js';
+export * from './type-assertions.js';
+export * from '@mtcute/tl-runtime';
+export { timers };

package/utils/linked-list.test.d.ts

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

package/utils/links/bots.d.ts

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { Deeplink } from './common.js';
+/**
+ * Bot deeplinks
+ *
+ * Used to link to bots with a start parameter
+ */
+export declare const botStart: Deeplink<{
+    /** Bot username */
+    username: string;
+    /** Start parameter */
+    parameter: string;
+}>;
+type BotAdminRight = Exclude<keyof tl.RawChatAdminRights, '_'>;
+/**
+ * Bot add to group links
+ *
+ * Used to ask the user to add a bot to a group, optionally asking for admin rights.
+ * Note that the user is still free to choose which rights to grant, and
+ * whether to grant them at all.
+ */
+export declare const botAddToGroup: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** If specified, the client will call `/start parameter` on the bot once the bot has been added */
+    parameter?: string;
+    /** Admin rights to request */
+    admin?: BotAdminRight[];
+}>;
+/**
+ * Bot add to channel links
+ *
+ * Used to ask the user to add a bot to a channel, optionally with admin rights.
+ * Note that the user is still free to choose which rights to grant, and
+ * whether to grant them at all.
+ */
+export declare const botAddToChannel: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** Admin rights to request */
+    admin?: BotAdminRight[];
+}>;
+/**
+ * Game links
+ *
+ * Used to share games.
+ */
+export declare const botGame: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** Game short name */
+    game: string;
+}>;
+/**
+ * Named bot web app links
+ *
+ * Used to share named bot web apps.
+ *
+ * These links are different from bot attachment menu deep links,
+ * because they don't require the user to install an attachment menu,
+ * and a single bot can offer multiple named web apps, distinguished by
+ * their `short_name`.
+ */
+export declare const botWebApp: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** App short name */
+    app: string;
+    /** Parameter to be passed by the client to messages.requestAppWebView as `start_param` */
+    parameter?: string;
+}>;
+export {};

package/utils/links/bots.test.d.ts

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

package/utils/links/calls.d.ts

@@ -0,0 +1,17 @@
+import { Deeplink } from './common.js';
+/**
+ * Video chat/Livestream links
+ *
+ * Used to join video/voice chats in groups, and livestreams in channels.
+ * Such links are generated using phone.exportGroupCallInvite.
+ */
+export declare const videoChat: Deeplink<{
+    username: string;
+    /**
+     * Invite hash exported if the `can_self_unmute` flag is set when calling `phone.exportGroupCallInvite`:
+     * should be passed to `phone.joinGroupCall`, allows the user to speak in livestreams
+     * or muted group chats.
+     */
+    inviteHash?: string;
+    isLivestream?: boolean;
+}>;

package/utils/links/chat.d.ts

@@ -0,0 +1,47 @@
+import { Deeplink } from './common.js';
+/**
+ * Chat invite links
+ *
+ * Used to invite users to private groups and channels
+ */
+export declare const chatInvite: Deeplink<{
+    hash: string;
+}>;
+/**
+ * Chat folder links
+ */
+export declare const chatFolder: Deeplink<{
+    slug: string;
+}>;
+/**
+ * Message links
+ *
+ * Used to link to specific messages in public or private groups and channels.
+ *
+ * Note: `channelId` is a non-marked channel ID
+ */
+export declare const message: Deeplink<({
+    username: string;
+} | {
+    channelId: number;
+}) & {
+    /** Message ID */
+    id: number;
+    /** Thread ID */
+    threadId?: number;
+    /**
+     * For comments, `id` will contain the message ID of the channel message that started
+     * the comment section and this field will contain the message ID of the comment in
+     * the discussion group.
+     */
+    commentId?: number;
+    /**
+     * Timestamp at which to start playing the media file present
+     * in the body or in the webpage preview of the message
+     */
+    mediaTimestamp?: number;
+    /**
+     * Whether this is a link to a specific message in the album or to the entire album
+     */
+    single?: boolean;
+}>;

package/utils/links/chat.test.d.ts

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

package/utils/links/misc.d.ts

@@ -0,0 +1,26 @@
+import { Deeplink } from './common.js';
+/**
+ * Share links
+ *
+ * Used to share a prepared message and URL into a chosen chat's text field.
+ */
+export declare const share: Deeplink<{
+    url: string;
+    text?: string;
+}>;
+/**
+ * Boost links
+ *
+ * Used by users to boost channels, granting them the ability to post stories.
+ */
+export declare const boost: Deeplink<{
+    username: string;
+} | {
+    channelId: number;
+}>;
+/**
+ * Link to a shared folder (chat list)
+ */
+export declare const folder: Deeplink<{
+    slug: string;
+}>;

package/utils/links/misc.test.d.ts

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

package/utils/links/proxy.d.ts

@@ -0,0 +1,18 @@
+import { Deeplink } from './common.js';
+/**
+ * MTProxy links
+ */
+export declare const mtproxy: Deeplink<{
+    server: string;
+    port: number;
+    secret: string;
+}>;
+/**
+ * Socks5 proxy links
+ */
+export declare const socks5: Deeplink<{
+    server: string;
+    port: number;
+    user?: string;
+    pass?: string;
+}>;

package/utils/links/proxy.test.d.ts

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

package/utils/links/stickers.d.ts

@@ -0,0 +1,10 @@
+import { Deeplink } from './common.js';
+/**
+ * Sticker set links
+ *
+ * Used to import stickersets or custom emoji stickersets
+ */
+export declare const stickerset: Deeplink<{
+    slug: string;
+    emoji?: boolean;
+}>;

package/utils/links/user.d.ts

@@ -0,0 +1,28 @@
+import { Deeplink } from './common.js';
+/**
+ * Public username links
+ *
+ * Used to link to public users, groups and channels
+ */
+export declare const publicUsername: Deeplink<{
+    username: string;
+}>;
+/**
+ * Temporary profile links
+ *
+ * Used to link to user profiles, generated using contacts.exportContactToken.
+ * These links can be generated even for profiles that don't have a username,
+ * and they have an expiration date, specified by the expires field of the exportedContactToken
+ * constructor returned by contacts.exportContactToken.
+ */
+export declare const temporaryProfile: Deeplink<{
+    token: string;
+}>;
+/**
+ * Phone number links
+ *
+ * Used to link to public and private users by their phone number.
+ */
+export declare const phoneNumber: Deeplink<{
+    phone: string;
+}>;

package/utils/links/user.test.d.ts

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

package/utils/logger.d.ts

@@ -0,0 +1,55 @@
+import { ICorePlatform } from '../platform.js';
+/**
+ * Logger created by {@link LogManager}
+ */
+export declare class Logger {
+    readonly mgr: LogManager;
+    readonly tag: string;
+    readonly parent: Logger;
+    private color;
+    prefix: string;
+    constructor(mgr: LogManager, tag: string, parent?: Logger);
+    getPrefix(): string;
+    log(level: number, fmt: string, ...args: unknown[]): void;
+    readonly error: (fmt: string, ...args: unknown[]) => void;
+    readonly warn: (fmt: string, ...args: unknown[]) => void;
+    readonly info: (fmt: string, ...args: unknown[]) => void;
+    readonly debug: (fmt: string, ...args: unknown[]) => void;
+    readonly verbose: (fmt: string, ...args: unknown[]) => void;
+    /**
+     * Create a {@link Logger} with the given tag
+     * from the same {@link LogManager} as the current
+     * Logger.
+     *
+     * @param tag  Logger tag
+     */
+    create(tag: string): Logger;
+}
+/**
+ * Log manager. A logger that allows managing child loggers
+ */
+export declare class LogManager extends Logger {
+    static OFF: number;
+    static ERROR: number;
+    static WARN: number;
+    static INFO: number;
+    static DEBUG: number;
+    static VERBOSE: number;
+    readonly platform: ICorePlatform;
+    level: number;
+    handler: (color: number, level: number, tag: string, fmt: string, args: unknown[]) => void;
+    constructor(tag?: string);
+    private _filter;
+    /**
+     * Create a {@link Logger} with the given tag
+     *
+     * @param tag  Logger tag
+     */
+    create(tag: string): Logger;
+    /**
+     * Filter logging by tags.
+     *
+     * @param cb
+     */
+    filter(cb: ((tag: string) => boolean) | null): void;
+}

package/utils/logger.test.d.ts

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