@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/worker/protocol.d.cts

@@ -0,0 +1,57 @@
+import { tl } from '@mtcute/tl';
+import { Worker as NodeWorker } from 'node:worker_threads';
+import { ConnectionState } from '../client.types.js';
+import { SerializedError } from './errors.js';
+export type WorkerInboundMessage = {
+    type: 'invoke';
+    id: number;
+    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
+    method: string;
+    args: SerializedResult<unknown[]>;
+    void: boolean;
+    withAbort: boolean;
+} | {
+    type: 'abort';
+    id: number;
+};
+export type WorkerOutboundMessage = {
+    type: 'server_update';
+    update: SerializedResult<tl.TypeUpdates>;
+} | {
+    type: 'update';
+    update: SerializedResult<tl.TypeUpdate>;
+    users: SerializedResult<Map<number, tl.TypeUser>>;
+    chats: SerializedResult<Map<number, tl.TypeChat>>;
+    hasMin: boolean;
+} | {
+    type: 'error';
+    error: SerializedError;
+} | {
+    type: 'stop';
+} | {
+    type: 'conn_state';
+    state: ConnectionState;
+} | {
+    type: 'log';
+    color: number;
+    level: number;
+    tag: string;
+    fmt: string;
+    args: unknown[];
+} | {
+    type: 'result';
+    id: number;
+    result?: SerializedResult<unknown>;
+    error?: SerializedError;
+};
+export type SomeWorker = NodeWorker | Worker | SharedWorker;
+export type SendFn = (message: WorkerInboundMessage) => void;
+export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;
+export type RespondFn = (message: WorkerOutboundMessage) => void;
+export type WorkerMessageHandler = (message: WorkerInboundMessage, respond: RespondFn) => void;
+export type WorkerCustomMethods = Record<string, (...args: any[]) => Promise<any>>;
+export interface SerializedResult<T> {
+    __serialized__: T;
+}
+export declare function serializeResult<T>(result: T): SerializedResult<T>;
+export declare function deserializeResult<T>(result: SerializedResult<T>): T;

package/highlevel/worker/storage.d.cts

@@ -0,0 +1,39 @@
+import { tl } from '@mtcute/tl';
+import { PublicPart } from '../../types/utils.js';
+import { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js';
+import { PeersService } from '../storage/service/peers.js';
+import { TelegramStorageManager } from '../storage/storage.js';
+import { WorkerInvoker } from './invoker.js';
+declare class CurrentUserServiceProxy implements PublicPart<CurrentUserService> {
+    private _store;
+    private _storeFrom;
+    private _fetch;
+    private _update;
+    constructor(invoker: WorkerInvoker);
+    private _cached?;
+    store(info: CurrentUserInfo | null): Promise<void>;
+    storeFrom(user: tl.TypeUser): Promise<CurrentUserInfo>;
+    fetch(): Promise<CurrentUserInfo | null>;
+    getCached(safe?: boolean): CurrentUserInfo | null;
+    update(params: Parameters<CurrentUserService['update']>[0]): Promise<void>;
+}
+declare class PeersServiceProxy implements PublicPart<PeersService> {
+    private _invoker;
+    readonly updatePeersFrom: PeersService['updatePeersFrom'];
+    readonly store: PeersService['store'];
+    readonly getById: PeersService['getById'];
+    readonly getByPhone: PeersService['getByPhone'];
+    readonly getByUsername: PeersService['getByUsername'];
+    readonly getCompleteById: PeersService['getCompleteById'];
+    constructor(_invoker: WorkerInvoker);
+}
+export declare class TelegramStorageProxy implements PublicPart<TelegramStorageManager> {
+    private _invoker;
+    readonly self: CurrentUserServiceProxy;
+    readonly peers: PeersServiceProxy;
+    readonly clear: TelegramStorageManager['clear'];
+    constructor(_invoker: WorkerInvoker);
+    readonly updates: never;
+    readonly refMsgs: never;
+}
+export {};

package/highlevel/worker/worker.d.cts

@@ -0,0 +1,15 @@
+import { BaseTelegramClient } from '../base.js';
+import { RespondFn, WorkerCustomMethods, WorkerMessageHandler } from './protocol.js';
+export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
+    client: BaseTelegramClient;
+    customMethods?: T;
+}
+export declare abstract class TelegramWorker<T extends WorkerCustomMethods> {
+    readonly params: TelegramWorkerOptions<T>;
+    readonly client: BaseTelegramClient;
+    readonly broadcast: RespondFn;
+    abstract registerWorker(handler: WorkerMessageHandler): RespondFn;
+    readonly pendingAborts: Map<number, AbortController>;
+    constructor(params: TelegramWorkerOptions<T>);
+    private onInvoke;
+}

package/index.cjs

@@ -62,6 +62,7 @@ const bundle = require("./highlevel/types/misc/input-privacy-rule/bundle.cjs");
 const stickerSet = require("./highlevel/types/misc/sticker-set.cjs");
 const takeoutSession = require("./highlevel/types/misc/takeout-session.cjs");
 const botInfo = require("./highlevel/types/peers/bot-info.cjs");
+const chatColors = require("./highlevel/types/peers/chat-colors.cjs");
 const actions = require("./highlevel/types/peers/chat-event/actions.cjs");
 const index = require("./highlevel/types/peers/chat-event/index.cjs");
 const chatInviteLinkMember = require("./highlevel/types/peers/chat-invite-link-member.cjs");
@@ -86,11 +87,14 @@ const businessAccount = require("./highlevel/types/premium/business-account.cjs"
 const businessChatLink = require("./highlevel/types/premium/business-chat-link.cjs");
 const businessConnection = require("./highlevel/types/premium/business-connection.cjs");
 const businessIntro = require("./highlevel/types/premium/business-intro.cjs");
+const businessLocation = require("./highlevel/types/premium/business-location.cjs");
 const businessWorkHours = require("./highlevel/types/premium/business-work-hours.cjs");
 const starsGift = require("./highlevel/types/premium/stars-gift.cjs");
 const starsStatus = require("./highlevel/types/premium/stars-status.cjs");
 const starsTransaction = require("./highlevel/types/premium/stars-transaction.cjs");
+const emojiStatus = require("./highlevel/types/reactions/emoji-status.cjs");
 const peerReaction = require("./highlevel/types/reactions/peer-reaction.cjs");
+const reactionCount = require("./highlevel/types/reactions/reaction-count.cjs");
 const types = require("./highlevel/types/reactions/types.cjs");
 const allStories = require("./highlevel/types/stories/all-stories.cjs");
 const input = require("./highlevel/types/stories/interactive/input.cjs");
@@ -220,6 +224,7 @@ exports.StickerSet = stickerSet.StickerSet;
 exports.normalizeInputStickerSet = stickerSet.normalizeInputStickerSet;
 exports.TakeoutSession = takeoutSession.TakeoutSession;
 exports.BotInfo = botInfo.BotInfo;
+exports.ChatColors = chatColors.ChatColors;
 exports._actionFromTl = actions._actionFromTl;
 exports.ChatEvent = index.ChatEvent;
 exports.ChatInviteLinkMember = chatInviteLinkMember.ChatInviteLinkMember;
@@ -245,14 +250,17 @@ exports.BusinessAccount = businessAccount.BusinessAccount;
 exports.BusinessChatLink = businessChatLink.BusinessChatLink;
 exports.BusinessConnection = businessConnection.BusinessConnection;
 exports.BusinessIntro = businessIntro.BusinessIntro;
+exports.BusinessLocation = businessLocation.BusinessLocation;
 exports.BusinessWorkHours = businessWorkHours.BusinessWorkHours;
 exports.businessWorkHoursDaysToRaw = businessWorkHours.businessWorkHoursDaysToRaw;
 exports.StarGift = starsGift.StarGift;
 exports.UserStarGift = starsGift.UserStarGift;
 exports.StarsStatus = starsStatus.StarsStatus;
 exports.StarsTransaction = starsTransaction.StarsTransaction;
+exports.EmojiStatus = emojiStatus.EmojiStatus;
 exports.PaidPeerReaction = peerReaction.PaidPeerReaction;
 exports.PeerReaction = peerReaction.PeerReaction;
+exports.ReactionCount = reactionCount.ReactionCount;
 exports.normalizeInputReaction = types.normalizeInputReaction;
 exports.toReactionEmoji = types.toReactionEmoji;
 exports.AllStories = allStories.AllStories;

package/index.d.cts

@@ -0,0 +1,10 @@
+import { default as Long } from 'long';
+export * from './highlevel/index.js';
+export * from './network/index.js';
+export * from './storage/index.js';
+export * from './types/index.js';
+export * from './utils/peer-utils.js';
+/** @hidden */
+export { mtp, tl } from '@mtcute/tl';
+/** @hidden */
+export { Long };

package/index.js

@@ -55,6 +55,7 @@ import * as bundle from "./highlevel/types/misc/input-privacy-rule/bundle.js";
 import { StickerSet, normalizeInputStickerSet } from "./highlevel/types/misc/sticker-set.js";
 import { TakeoutSession } from "./highlevel/types/misc/takeout-session.js";
 import { BotInfo } from "./highlevel/types/peers/bot-info.js";
+import { ChatColors } from "./highlevel/types/peers/chat-colors.js";
 import { _actionFromTl } from "./highlevel/types/peers/chat-event/actions.js";
 import { ChatEvent } from "./highlevel/types/peers/chat-event/index.js";
 import { ChatInviteLinkMember } from "./highlevel/types/peers/chat-invite-link-member.js";
@@ -79,11 +80,14 @@ import { BusinessAccount } from "./highlevel/types/premium/business-account.js";
 import { BusinessChatLink } from "./highlevel/types/premium/business-chat-link.js";
 import { BusinessConnection } from "./highlevel/types/premium/business-connection.js";
 import { BusinessIntro } from "./highlevel/types/premium/business-intro.js";
+import { BusinessLocation } from "./highlevel/types/premium/business-location.js";
 import { BusinessWorkHours, businessWorkHoursDaysToRaw } from "./highlevel/types/premium/business-work-hours.js";
 import { StarGift, UserStarGift } from "./highlevel/types/premium/stars-gift.js";
 import { StarsStatus } from "./highlevel/types/premium/stars-status.js";
 import { StarsTransaction } from "./highlevel/types/premium/stars-transaction.js";
+import { EmojiStatus } from "./highlevel/types/reactions/emoji-status.js";
 import { PaidPeerReaction, PeerReaction } from "./highlevel/types/reactions/peer-reaction.js";
+import { ReactionCount } from "./highlevel/types/reactions/reaction-count.js";
 import { normalizeInputReaction, toReactionEmoji } from "./highlevel/types/reactions/types.js";
 import { AllStories } from "./highlevel/types/stories/all-stories.js";
 import { StoryElement } from "./highlevel/types/stories/interactive/input.js";
@@ -160,10 +164,12 @@ export {
   BusinessChatLink,
   BusinessConnection,
   BusinessIntro,
+  BusinessLocation,
   BusinessMessage,
   BusinessWorkHours,
   CallbackQuery,
   Chat,
+  ChatColors,
   ChatEvent,
   ChatInviteLink,
   ChatInviteLinkMember,
@@ -187,6 +193,7 @@ export {
   Dice,
   Document,
   DraftMessage,
+  EmojiStatus,
   ExtendedMediaPreview,
   FactCheck,
   FileLocation,
@@ -242,6 +249,7 @@ export {
   RawDocument,
   RawLocation,
   RawUpdateInfo,
+  ReactionCount,
   RepliedMessageInfo,
   SearchFilters,
   SentCode,

package/methods.d.cts

@@ -0,0 +1 @@
+export * from "./highlevel/methods.js"

package/network/auth-key.d.cts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { TlReaderMap, TlBinaryReader } from '@mtcute/tl-runtime';
+import { default as Long } from 'long';
+import { ICryptoProvider, Logger } from '../utils/index.js';
+export declare class AuthKey {
+    readonly _crypto: ICryptoProvider;
+    readonly log: Logger;
+    readonly _readerMap: TlReaderMap;
+    ready: boolean;
+    key: Uint8Array;
+    id: Uint8Array;
+    clientSalt: Uint8Array;
+    serverSalt: Uint8Array;
+    constructor(_crypto: ICryptoProvider, log: Logger, _readerMap: TlReaderMap);
+    match(keyId: Uint8Array): boolean;
+    setup(authKey?: Uint8Array | null): void;
+    encryptMessage(message: Uint8Array, serverSalt: Long, sessionId: Long): Uint8Array;
+    decryptMessage(data: Uint8Array, sessionId: Long, callback: (msgId: tl.Long, seqNo: number, data: TlBinaryReader) => void): void;
+    copyFrom(authKey: AuthKey): void;
+    reset(): void;
+}

package/network/auth-key.test.d.cts

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

package/network/authorization.d.cts

@@ -0,0 +1,9 @@
+import { ICryptoProvider } from '../utils/index.js';
+import { SessionConnection } from './session-connection.js';
+import { default as Long } from 'long';
+/**
+ * Execute authorization flow on `connection` using `crypto`.
+ *
+ * @returns  tuple: [authKey, serverSalt, timeOffset]
+ */
+export declare function doAuthorization(connection: SessionConnection, crypto: ICryptoProvider, expiresIn?: number): Promise<[Uint8Array, Long, number]>;

package/network/client.d.cts

@@ -0,0 +1,218 @@
+import { ReconnectionStrategy } from '@fuman/net';
+import { mtp, tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { IMtStorageProvider } from '../storage/provider.js';
+import { StorageManagerExtraOptions, StorageManager } from '../storage/storage.js';
+import { MustEqual } from '../types/index.js';
+import { ICorePlatform } from '../types/platform.js';
+import { DcOptions, ICryptoProvider, Logger } from '../utils/index.js';
+import { NetworkManagerExtraParams, RpcCallOptions, NetworkManager } from './network-manager.js';
+import { TelegramTransport } from './transports/abstract.js';
+import { Emitter } from '@fuman/utils';
+import { ConfigManager } from './config-manager.js';
+/** Options for {@link MtClient} */
+export interface MtClientOptions {
+    /**
+     * API ID from my.telegram.org
+     */
+    apiId: number;
+    /**
+     * API hash from my.telegram.org
+     */
+    apiHash: string;
+    /**
+     * Storage to use for this client.
+     */
+    storage: IMtStorageProvider;
+    /** Additional options for the storage manager */
+    storageOptions?: StorageManagerExtraOptions;
+    /**
+     * Cryptography provider to allow delegating
+     * crypto to native addon, worker, etc.
+     */
+    crypto: ICryptoProvider;
+    platform: ICorePlatform;
+    /**
+     * Whether to use IPv6 datacenters
+     * (IPv6 will be preferred when choosing a DC by id)
+     * (default: false)
+     */
+    useIpv6?: boolean;
+    /**
+     * Primary DC to use for initial connection.
+     * This does not mean this will be the only DC used,
+     * nor that this DC will actually be primary, this only
+     * determines the first DC the library will try to connect to.
+     * Can be used to connect to other networks (like test DCs).
+     *
+     * When session already contains primary DC, this parameter is ignored.
+     *
+     * @default  Production DC 2.
+     */
+    defaultDcs?: DcOptions;
+    /**
+     * Whether to connect to test servers.
+     *
+     * If passed, {@link defaultDc} defaults to Test DC 2.
+     *
+     * **Must** be passed if using test servers, even if
+     * you passed custom {@link defaultDc}
+     */
+    testMode?: boolean;
+    /**
+     * Additional options for initConnection call.
+     * `apiId` and `query` are not available and will be ignored.
+     * Omitted values will be filled with defaults
+     */
+    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>;
+    /**
+     * Transport to use in the client.
+     *
+     * @default  platform-specific transport: WebSocket on the web, TCP in node
+     */
+    transport: TelegramTransport;
+    /**
+     * Reconnection strategy.
+     *
+     * @default  simple reconnection strategy: first 0ms, then up to 5s (increasing by 1s)
+     */
+    reconnectionStrategy?: ReconnectionStrategy;
+    /**
+     * If true, all API calls will be wrapped with `tl.invokeWithoutUpdates`,
+     * effectively disabling the server-sent events for the clients.
+     * May be useful in some cases.
+     *
+     * @default false
+     */
+    disableUpdates?: boolean;
+    /**
+     * mtcute can send all unknown RPC errors to [danog](https://github.com/danog)'s
+     * [error reporting service](https://report-rpc-error.madelineproto.xyz/).
+     *
+     * This is fully anonymous (except maybe IP) and is only used to improve the library
+     * and developer experience for everyone working with MTProto. This is fully opt-in,
+     * and if you're too paranoid, you can disable it by manually passing `enableErrorReporting: false` to the client.
+     *
+     * @default false
+     */
+    enableErrorReporting?: boolean;
+    /**
+     * Extra parameters for {@link NetworkManager}
+     */
+    network?: NetworkManagerExtraParams;
+    /**
+     * Logger instance for the client.
+     * If not passed, a new one will be created.
+     */
+    logger?: Logger;
+    /**
+     * Set logging level for the client.
+     * Shorthand for `client.log.level = level`.
+     *
+     * See static members of {@link LogManager} for possible values.
+     */
+    logLevel?: number;
+    /**
+     * **EXPERT USE ONLY!**
+     *
+     * Override TL layer used for the connection.
+     *
+     * **Does not** change the schema used.
+     */
+    overrideLayer?: number;
+    /**
+     * **EXPERT USE ONLY**
+     *
+     * Override reader map used for the connection.
+     */
+    readerMap?: TlReaderMap;
+    /**
+     * **EXPERT USE ONLY**
+     *
+     * Override writer map used for the connection.
+     */
+    writerMap?: TlWriterMap;
+}
+/**
+ * Basic MTProto client implementation, only doing the bare minimum
+ * to make RPC calls and receive low-level updates, as well as providing
+ * some APIs to manage that.
+ */
+export declare class MtClient {
+    readonly params: MtClientOptions;
+    /**
+     * Crypto provider taken from {@link MtClientOptions.crypto}
+     */
+    readonly crypto: ICryptoProvider;
+    /** Storage manager */
+    readonly storage: StorageManager;
+    /**
+     * "Test mode" taken from {@link MtClientOptions.testMode}
+     */
+    protected readonly _testMode: boolean;
+    /**
+     * Primary DCs taken from {@link MtClientOptions.defaultDcs},
+     * loaded from session or changed by other means (like redirecting).
+     */
+    _defaultDcs: DcOptions;
+    /** TL layer used by the client */
+    readonly _layer: number;
+    /** TL readers map used by the client */
+    readonly _readerMap: TlReaderMap;
+    /** TL writers map used by the client */
+    readonly _writerMap: TlWriterMap;
+    readonly _config: ConfigManager;
+    private _emitError?;
+    readonly log: Logger;
+    readonly network: NetworkManager;
+    private _abortController;
+    readonly stopSignal: AbortSignal;
+    readonly onUsable: Emitter<void>;
+    readonly onConnecting: Emitter<void>;
+    readonly onNetworkChanged: Emitter<boolean>;
+    readonly onUpdate: Emitter<tl.TypeUpdates>;
+    constructor(params: MtClientOptions);
+    emitError(err: unknown): void;
+    private _prepare;
+    /**
+     * **ADVANCED**
+     *
+     * Do all the preparations, but don't connect just yet.
+     * Useful when you want to do some preparations before
+     * connecting, like setting up session.
+     *
+     * Call {@link connect} to actually connect.
+     */
+    prepare(): Promise<void>;
+    private _connect;
+    /**
+     * Initialize the connection to the primary DC.
+     *
+     * You shouldn't usually call this method directly as it is called
+     * implicitly the first time you call {@link call}.
+     */
+    connect(): Promise<void>;
+    /**
+     * Close all connections and finalize the client.
+     */
+    close(): Promise<void>;
+    /**
+     * Make an RPC call.
+     *
+     * The connection must have been {@link connect}-ed
+     * before calling this method.
+     *
+     * This method is still quite low-level and you shouldn't use this
+     * when using high-level API provided by `@mtcute/client`.
+     *
+     * @param message  RPC method to call
+     * @param params  Additional call parameters
+     */
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    /**
+     * Register an error handler for the client
+     *
+     * @param handler Error handler.
+     */
+    onError(handler: (err: unknown) => void): void;
+}

package/network/config-manager.d.cts

@@ -0,0 +1,19 @@
+import { tl } from '@mtcute/tl';
+import { AsyncResource } from '@fuman/utils';
+/**
+ * Config manager is responsible for keeping
+ * the current server configuration up-to-date
+ * and providing methods to find the best DC
+ * option for the current session.
+ */
+export declare class ConfigManager extends AsyncResource<tl.RawConfig> {
+    constructor(update: () => Promise<tl.RawConfig>);
+    findOption(params: {
+        dcId: number;
+        allowIpv6?: boolean;
+        preferIpv6?: boolean;
+        allowMedia?: boolean;
+        preferMedia?: boolean;
+        cdn?: boolean;
+    }): Promise<tl.RawDcOption | undefined>;
+}

package/network/config-manager.test.d.cts

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

package/network/index.d.cts

@@ -0,0 +1,6 @@
+export * from './client.js';
+export * from './middlewares/index.js';
+export * from './mtproxy/index.js';
+export type { ConnectionKind, NetworkManagerExtraParams, RpcCallMiddleware, RpcCallMiddlewareContext, RpcCallOptions, } from './network-manager.js';
+export * from './session-connection.js';
+export * from './transports/index.js';

package/network/middlewares/bundle.d.cts

@@ -0,0 +1,3 @@
+export * from './default.js';
+export * from './on-error.js';
+export * from './on-method.js';

package/network/middlewares/default.d.cts

@@ -0,0 +1,8 @@
+import { RpcCallMiddleware } from '../network-manager.js';
+import { FloodWaiterOptions } from './flood-waiter.js';
+import { InternalErrorsHandlerOptions } from './internal-errors.js';
+export interface BasicMiddlewaresOptions {
+    floodWaiter?: FloodWaiterOptions;
+    internalErrors?: InternalErrorsHandlerOptions;
+}
+export declare function basic(options?: BasicMiddlewaresOptions): RpcCallMiddleware[];

package/network/middlewares/flood-waiter.d.cts

@@ -0,0 +1,37 @@
+import { RpcCallMiddleware } from '../network-manager.js';
+export interface FloodWaiterOptions {
+    /**
+     * Maximum number of ms to wait when a FLOOD_WAIT_X
+     * error is encountered. If the wait time is greater
+     * than this value, the request will throw an error instead
+     *
+     * This can be overwritten on a per-request basis by setting
+     * `floodSleepThreshold` in the request parameters
+     *
+     * @default  10_000
+     */
+    maxWait?: number;
+    /**
+     * Maximum number of retries to perform when a FLOOD_WAIT_X
+     * error is encountered. After this number of retries, the
+     * last error will be thrown
+     *
+     * @default  5
+     */
+    maxRetries?: number;
+    /**
+     * Whether to store the last flood wait time and delay
+     * the consecutive requests accordingly
+     *
+     * @default  true
+     */
+    store?: boolean;
+    /**
+     * If the stored wait time is less than this value,
+     * the request will not be delayed
+     *
+     * @default  3_000
+     */
+    minStoredWait?: number;
+}
+export declare function floodWaiter(options: FloodWaiterOptions): RpcCallMiddleware;

package/network/middlewares/index.d.cts

@@ -0,0 +1,4 @@
+import * as networkMiddlewares from './bundle.js';
+export type { FloodWaiterOptions } from './flood-waiter.js';
+export type { InternalErrorsHandlerOptions } from './internal-errors.js';
+export { networkMiddlewares };

package/network/middlewares/index.d.ts

@@ -1,2 +1,4 @@
 import * as networkMiddlewares from './bundle.js';
+export type { FloodWaiterOptions } from './flood-waiter.js';
+export type { InternalErrorsHandlerOptions } from './internal-errors.js';
 export { networkMiddlewares };

package/network/middlewares/internal-errors.d.cts

@@ -0,0 +1,17 @@
+import { RpcCallMiddleware } from '../network-manager.js';
+export interface InternalErrorsHandlerOptions {
+    /**
+     * Maximum number of retries to perform when an internal server error is encountered.
+     *
+     * @default  Infinity
+     */
+    maxRetries?: number;
+    /**
+     * Number of seconds to wait before retrying
+     * when an internal server error is encountered.
+     *
+     * @default 1
+     */
+    waitTime?: number;
+}
+export declare function internalErrorsHandler(params: InternalErrorsHandlerOptions): RpcCallMiddleware;

package/network/middlewares/on-error.d.cts

@@ -0,0 +1,30 @@
+import { mtp } from '@mtcute/tl';
+import { MaybePromise } from '../../types/utils.js';
+import { RpcCallMiddleware, RpcCallMiddlewareContext } from '../network-manager.js';
+/**
+ * Middleware that will call `handler` whenever an RPC error happens,
+ * with the error object itself.
+ *
+ * The handler can either return nothing
+ * (in which case the original error will be thrown), a new error
+ * (via the `_: 'mt_rpc_error'` object), or any other value, which
+ * will be returned as the result of the RPC call.
+ *
+ * Note that the return value is **not type-checked**
+ * due to limitations of TypeScript. You'll probably want to use `satisfies`
+ * keyword to ensure the return value is correct, for example:
+ *
+ * ```ts
+ * networkMiddlewares.onRpcError(async (ctx, error) => {
+ *   if (rpc.request._ === 'help.getNearestDc') {
+ *     return {
+ *       _: 'nearestDc',
+ *       country: 'RU',
+ *       thisDc: 2,
+ *       nearestDc: 2,
+ *     } satisfies tl.RpcCallReturn['help.getNearestDc']
+ *   }
+ * })
+ * ```
+ */
+export declare function onRpcError(handler: (ctx: RpcCallMiddlewareContext, error: mtp.RawMt_rpc_error) => MaybePromise<unknown>): RpcCallMiddleware;

package/network/middlewares/on-method.d.cts

@@ -0,0 +1,39 @@
+import { Middleware } from '@fuman/utils';
+import { tl } from '@mtcute/tl';
+import { RpcCallMiddleware, RpcCallMiddlewareContext } from '../network-manager.js';
+/**
+ * Middleware that will call `handler` whenever `method` RPC method is called.
+ *
+ * This helper exists due to TypeScript limitations not allowing us to
+ * properly type the return type without explicit type annotations,
+ * for a bit more type-safe and clean code:
+ *
+ * ```ts
+ * // before
+ * async (ctx, next) => {
+ *   if (rpc.request._ === 'help.getNearestDc') {
+ *     return {
+ *       _: 'nearestDc',
+ *       country: 'RU',
+ *       thisDc: 2,
+ *       nearestDc: 2,
+ *     } satisfies tl.RpcCallReturn['help.getNearestDc']
+ *   }
+ *
+ *   return next(ctx)
+ * }
+ *
+ * // after
+ * onMethod('help.getNearestDc', async () => ({
+ *   _: 'nearestDc' as const, // (otherwise ts will infer this as `string` and will complain)
+ *   country: 'RU',
+ *   thisDc: 2,
+ *   nearestDc: 2,
+ * })
+ * ```
+ */
+export declare function onMethod<T extends tl.RpcMethod['_']>(method: T, middleware: Middleware<Omit<RpcCallMiddlewareContext, 'request'> & {
+    request: Extract<tl.RpcMethod, {
+        _: T;
+    }>;
+}, tl.RpcCallReturn[T]>): RpcCallMiddleware;