@mtcute/core 0.18.0-rc.5 → 0.18.0

package/network/session-connection.d.cts

@@ -0,0 +1,94 @@
+import { mtp, tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { ICorePlatform } from '../types/platform.js';
+import { Logger } from '../utils/index.js';
+import { PersistentConnectionParams, PersistentConnection } from './persistent-connection.js';
+import { ServerSaltManager } from './server-salt.js';
+import { Emitter } from '@fuman/utils';
+import { MtprotoSession } from './mtproto-session.js';
+export interface SessionConnectionParams extends PersistentConnectionParams {
+    initConnection: tl.RawInitConnectionRequest;
+    inactivityTimeout?: number;
+    pingInterval: number;
+    enableErrorReporting: boolean;
+    layer: number;
+    disableUpdates?: boolean;
+    withUpdates?: boolean;
+    isMainConnection: boolean;
+    isMainDcConnection: boolean;
+    usePfs?: boolean;
+    salts: ServerSaltManager;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+    platform: ICorePlatform;
+}
+/**
+ * A connection to a single DC.
+ */
+export declare class SessionConnection extends PersistentConnection {
+    readonly params: SessionConnectionParams;
+    private _flushTimer;
+    private _queuedDestroySession;
+    private _pendingWaitForUnencrypted;
+    private _usePfs;
+    private _isPfsBindingPending;
+    private _isPfsBindingPendingInBackground;
+    private _pfsUpdateTimeout?;
+    private _inactivityPendingFlush;
+    private _readerMap;
+    private _writerMap;
+    private _crypto;
+    private _salts;
+    readonly _session: MtprotoSession;
+    private _pingInterval;
+    readonly onDisconnect: Emitter<void>;
+    readonly onKeyChange: Emitter<Uint8Array | null>;
+    readonly onTmpKeyChange: Emitter<[Uint8Array, number] | null>;
+    readonly onFloodDone: Emitter<void>;
+    readonly onRequestAuth: Emitter<void>;
+    readonly onAuthBegin: Emitter<void>;
+    readonly onUpdate: Emitter<tl.TypeUpdates>;
+    readonly onFutureSalts: Emitter<mtp.RawMt_future_salt[]>;
+    private _triedReconnectingOn404;
+    constructor(params: SessionConnectionParams, log: Logger);
+    private _online;
+    getAuthKey(temp?: boolean): Uint8Array | null;
+    setUsePfs(usePfs: boolean): void;
+    onClosed(): void;
+    destroy(): Promise<void>;
+    reset(forever?: boolean): void;
+    onConnected(): void;
+    protected handleError(error: Error): void;
+    protected onConnectionUsable(): void;
+    _authorize(): void;
+    private _authorizePfs;
+    waitForUnencryptedMessage(timeout?: number): Promise<Uint8Array>;
+    protected onMessage(data: Uint8Array): void;
+    private _handleRawMessage;
+    private _handleMessage;
+    private _onRpcResult;
+    private _processPendingChainedFails;
+    private _onMessageAcked;
+    private _onAllFailed;
+    private _onMessageFailed;
+    private _registerOutgoingMsgId;
+    private _onPong;
+    private _onBadServerSalt;
+    private _onBadMsgNotification;
+    private _onNewSessionCreated;
+    private _onMessageInfo;
+    private _onMessagesInfo;
+    private _onMsgsStateInfo;
+    private _onFutureSalts;
+    private _onDestroySessionResult;
+    private _enqueueRpc;
+    _resetSession(): void;
+    private _sendAck;
+    sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']]>;
+    notifyNetworkChanged(online: boolean): void;
+    private _cancelRpc;
+    protected _onInactivityTimeout(): void;
+    flushWhenIdle(): void;
+    private _flush;
+    private _doFlush;
+}

package/network/session-connection.d.ts

@@ -1,10 +1,11 @@
 import { mtp, tl } from '@mtcute/tl';
 import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
 import { ICorePlatform } from '../types/platform.js';
-import { MtprotoSession } from './mtproto-session.js';
+import { Logger } from '../utils/index.js';
 import { PersistentConnectionParams, PersistentConnection } from './persistent-connection.js';
 import { ServerSaltManager } from './server-salt.js';
 import { Emitter } from '@fuman/utils';
+import { MtprotoSession } from './mtproto-session.js';
 export interface SessionConnectionParams extends PersistentConnectionParams {
     initConnection: tl.RawInitConnectionRequest;
     inactivityTimeout?: number;
@@ -25,7 +26,6 @@ export interface SessionConnectionParams extends PersistentConnectionParams {
  * A connection to a single DC.
  */
 export declare class SessionConnection extends PersistentConnection {
-    readonly _session: MtprotoSession;
     readonly params: SessionConnectionParams;
     private _flushTimer;
     private _queuedDestroySession;
@@ -39,6 +39,7 @@ export declare class SessionConnection extends PersistentConnection {
     private _writerMap;
     private _crypto;
     private _salts;
+    readonly _session: MtprotoSession;
     private _pingInterval;
     readonly onDisconnect: Emitter<void>;
     readonly onKeyChange: Emitter<Uint8Array | null>;
@@ -48,7 +49,8 @@ export declare class SessionConnection extends PersistentConnection {
     readonly onAuthBegin: Emitter<void>;
     readonly onUpdate: Emitter<tl.TypeUpdates>;
     readonly onFutureSalts: Emitter<mtp.RawMt_future_salt[]>;
-    constructor(params: SessionConnectionParams, _session: MtprotoSession);
+    private _triedReconnectingOn404;
+    constructor(params: SessionConnectionParams, log: Logger);
     private _online;
     getAuthKey(temp?: boolean): Uint8Array | null;
     setUsePfs(usePfs: boolean): void;

package/network/session-connection.js

@@ -6,6 +6,7 @@ import { createAesIgeForMessageOld } from "../utils/crypto/mtproto.js";
 import { EarlyTimer } from "../utils/early-timer.js";
 import { longFromBuffer, randomLong, removeFromLongArray } from "../utils/long-utils.js";
 import { doAuthorization } from "./authorization.js";
+import { MtprotoSession } from "./mtproto-session.js";
 import { PersistentConnection } from "./persistent-connection.js";
 import { TransportError } from "./transports/abstract.js";
 import { MtcuteError, MtTimeoutError, MtArgumentError } from "../types/errors.js";
@@ -18,19 +19,6 @@ const RPC_ERROR_ID = 558156313;
 const INVOKE_AFTER_MSG_ID = 3416209197;
 const INVOKE_AFTER_MSG_SIZE = 12;
 class SessionConnection extends PersistentConnection {
-  constructor(params, _session) {
-    super(params, _session.log.create("conn"));
-    this._session = _session;
-    this._flushTimer.onTimeout(this._flush.bind(this));
-    this._pingInterval = params.pingInterval;
-    this._readerMap = params.readerMap;
-    this._writerMap = params.writerMap;
-    this._crypto = params.crypto;
-    this._salts = params.salts;
-    this._handleRawMessage = this._handleRawMessage.bind(this);
-    this._usePfs = this.params.usePfs ?? false;
-    this._online = params.platform.isOnline?.() ?? true;
-  }
   _flushTimer = new EarlyTimer();
   _queuedDestroySession = [];
   // waitForMessage
@@ -44,6 +32,7 @@ class SessionConnection extends PersistentConnection {
   _writerMap;
   _crypto;
   _salts;
+  _session;
   // todo: we should probably do adaptive ping interval based on rtt like tdlib:
   // https://github.com/tdlib/td/blob/91aa6c9e4d0774eabf4f8d7f3aa51239032059a6/td/mtproto/SessionConnection.h
   _pingInterval;
@@ -56,6 +45,26 @@ class SessionConnection extends PersistentConnection {
   onAuthBegin = new Emitter();
   onUpdate = new Emitter();
   onFutureSalts = new Emitter();
+  _triedReconnectingOn404 = false;
+  constructor(params, log) {
+    super(params, log.create("conn"));
+    this._session = new MtprotoSession(
+      params.crypto,
+      log.create("session"),
+      params.readerMap,
+      params.writerMap,
+      params.salts
+    );
+    this._flushTimer.onTimeout(this._flush.bind(this));
+    this._pingInterval = params.pingInterval;
+    this._readerMap = params.readerMap;
+    this._writerMap = params.writerMap;
+    this._crypto = params.crypto;
+    this._salts = params.salts;
+    this._handleRawMessage = this._handleRawMessage.bind(this);
+    this._usePfs = this.params.usePfs ?? false;
+    this._online = params.platform.isOnline?.() ?? true;
+  }
   _online;
   getAuthKey(temp = false) {
     const key = temp ? this._session._authKeyTemp : this._session._authKey;
@@ -112,6 +121,7 @@ class SessionConnection extends PersistentConnection {
       this.onError.add((err) => {
         this.log.warn("caught error after destroying: %s", err);
       });
+      this._session.reset();
     }
   }
   onConnected() {
@@ -137,22 +147,27 @@ class SessionConnection extends PersistentConnection {
       if (error.code === 404) {
         if (this._usePfs) {
           if (!this._isPfsBindingPending && this._session._authKeyTemp.ready) {
-            this.log.info("transport error 404, reauthorizing pfs");
+            this.log.debug("transport error 404, reauthorizing pfs");
             this._session._authKeyTemp.reset();
             this._authorizePfs();
             this._onAllFailed("temp key expired, binding started");
             return;
           } else if (this._isPfsBindingPending) {
-            this.log.info("transport error 404, pfs binding in progress");
+            this.log.debug("transport error 404, pfs binding in progress");
             this._onAllFailed("temp key expired, binding pending");
             return;
           }
         }
-        this.log.info("transport error 404, reauthorizing");
+        if (!this._triedReconnectingOn404) {
+          this.log.warn("transport error 404. trying to reconnect");
+          this._triedReconnectingOn404 = true;
+          this._resetSession();
+          return;
+        }
+        this.log.warn("transport error 404, reauthorizing");
         this._session.resetAuthKey();
         this._resetSession();
         this.onKeyChange.emit(null);
-        this.onError.emit(error);
         return;
       }
       this.log.error("transport error %d", error.code);
@@ -778,6 +793,7 @@ class SessionConnection extends PersistentConnection {
       this.onUpdate.emit({ _: "updatesTooLong" });
     }
     this._salts.currentSalt = serverSalt;
+    this._triedReconnectingOn404 = false;
     this.log.debug("received new_session_created, uid = %l, first msg_id = %l", uniqueId, firstMsgId);
     for (const msgId of this._session.pendingMessages.keys()) {
       const val = this._session.pendingMessages.get(msgId);
@@ -928,7 +944,7 @@ class SessionConnection extends PersistentConnection {
         layer: this.params.layer,
         query: {
           ...this.params.initConnection,
-          // proxy,
+          proxy: this._mtproxyInfo,
           query: obj
         }
       };
@@ -994,6 +1010,7 @@ class SessionConnection extends PersistentConnection {
   notifyNetworkChanged(online) {
     this._online = online;
     if (online) {
+      if (this._inactive) return;
       this.reconnect();
     } else {
       this.disconnectManual().catch((err) => {

package/network/transports/abstract.d.cts

@@ -0,0 +1,47 @@
+import { IFrameDecoder, IFrameEncoder } from '@fuman/io';
+import { IConnection } from '@fuman/net';
+import { tl } from '@mtcute/tl';
+import { MaybePromise } from '../../types/index.js';
+import { BasicDcOption, ICryptoProvider, Logger } from '../../utils/index.js';
+/**
+ * Interface implementing a transport to interact with Telegram servers.
+ */
+export interface ITelegramConnection extends IConnection<any, any> {
+    /**
+     * Provides crypto and logging for the transport.
+     * Not done in constructor to simplify factory.
+     *
+     * This method is called before any other.
+     */
+    setup?(crypto: ICryptoProvider, log: Logger): void;
+    getMtproxyInfo?(): tl.RawInputClientProxy;
+}
+export interface TelegramTransport {
+    setup?(crypto: ICryptoProvider, log: Logger): void;
+    connect: (dc: BasicDcOption) => Promise<ITelegramConnection>;
+    packetCodec: (dc: BasicDcOption) => IPacketCodec;
+}
+/**
+ * Interface declaring handling of received packets.
+ * When receiving a packet, its content is sent to feed(),
+ * and codec is supposed to emit `packet` or `error` event when packet is parsed.
+ */
+export interface IPacketCodec extends IFrameDecoder, IFrameEncoder {
+    /** Initial tag of the codec. Will be sent immediately once connected. */
+    tag(): MaybePromise<Uint8Array>;
+    /**
+     * For codecs that use crypto functions and/or logging.
+     * This method is called before any other.
+     */
+    setup?(crypto: ICryptoProvider, log: Logger): void;
+}
+/**
+ * Error that represents an error in an underlying transport
+ * (and usually means either server-side problems or bug in library)
+ *
+ * More: https://core.telegram.org/mtproto/mtproto-transports#transport-errors
+ */
+export declare class TransportError extends Error {
+    code: number;
+    constructor(code: number);
+}

package/network/transports/index.d.cts

@@ -0,0 +1,3 @@
+export * from './abstract.js';
+export * from './intermediate.js';
+export * from './obfuscated.js';

package/network/transports/intermediate.d.cts

@@ -0,0 +1,23 @@
+import { Bytes, ISyncWritable } from '@fuman/io';
+import { ICryptoProvider } from '../../utils/index.js';
+import { IPacketCodec } from './abstract.js';
+/**
+ * Intermediate packet codec.
+ * See https://core.telegram.org/mtproto/mtproto-transports#intermediate
+ */
+export declare class IntermediatePacketCodec implements IPacketCodec {
+    tag(): Uint8Array;
+    decode(reader: Bytes, eof: boolean): Uint8Array | null;
+    encode(frame: Uint8Array, into: ISyncWritable): void;
+    reset(): void;
+}
+/**
+ * Padded intermediate packet codec.
+ * See https://core.telegram.org/mtproto/mtproto-transports#padded-intermediate
+ */
+export declare class PaddedIntermediatePacketCodec extends IntermediatePacketCodec implements IPacketCodec {
+    tag(): Uint8Array;
+    private _crypto;
+    setup?(crypto: ICryptoProvider): void;
+    encode(frame: Uint8Array, into: ISyncWritable): void;
+}

package/network/transports/intermediate.test.d.cts

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

package/network/transports/obfuscated.d.cts

@@ -0,0 +1,23 @@
+import { ISyncWritable, Bytes } from '@fuman/io';
+import { ICryptoProvider, Logger } from '../../utils/index.js';
+import { IPacketCodec } from './abstract.js';
+export interface MtProxyInfo {
+    dcId: number;
+    secret: Uint8Array;
+    test: boolean;
+    media: boolean;
+}
+export declare class ObfuscatedPacketCodec implements IPacketCodec {
+    private _encryptor?;
+    private _decryptor?;
+    private _crypto;
+    private _inner;
+    private _proxy?;
+    setup(crypto: ICryptoProvider, log: Logger): void;
+    constructor(inner: IPacketCodec, proxy?: MtProxyInfo);
+    tag(): Promise<Uint8Array>;
+    encode(packet: Uint8Array, into: ISyncWritable): Promise<void>;
+    private _decodeBuf;
+    decode(reader: Bytes, eof: boolean): Promise<Uint8Array | null>;
+    reset(): void;
+}

package/network/transports/obfuscated.test.d.cts

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

package/package.json

@@ -1,22 +1,17 @@
 {
     "name": "@mtcute/core",
     "type": "module",
-    "version": "0.18.0-rc.5",
+    "version": "0.18.0",
     "description": "Type-safe library for MTProto (Telegram API)",
     "license": "MIT",
-    "homepage": "https://mtcute.dev",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/mtcute/mtcute.git"
-    },
     "scripts": {},
     "dependencies": {
-        "@fuman/io": "0.0.3",
-        "@fuman/net": "0.0.3",
-        "@fuman/utils": "0.0.3",
-        "@mtcute/file-id": "0.18.0-rc.5",
-        "@mtcute/tl": "0.18.0-rc.5",
-        "@mtcute/tl-runtime": "0.18.0-rc.5",
+        "@fuman/io": "0.0.4",
+        "@fuman/net": "0.0.4",
+        "@fuman/utils": "0.0.4",
+        "@mtcute/file-id": "^0.18.0",
+        "@mtcute/tl": "^195.0.0",
+        "@mtcute/tl-runtime": "^0.17.0",
         "@types/events": "3.0.0",
         "events": "3.2.0",
         "long": "5.2.3"
@@ -74,5 +69,10 @@
         }
     },
     "author": "alina sireneva <alina@tei.su>",
-    "sideEffects": false
+    "sideEffects": false,
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    }
 }

package/storage/driver.d.cts

@@ -0,0 +1,58 @@
+import { ICorePlatform } from '../types/platform.js';
+import { MaybePromise } from '../types/utils.js';
+import { Logger } from '../utils/logger.js';
+/**
+ * Basic storage driver interface,
+ * describing the lifecycle of a storage driver
+ */
+export interface IStorageDriver {
+    /**
+     * Load session from some external storage.
+     * Should be used either to load data from file/network/etc
+     * to memory, or to open required connections to fetch data on demand
+     *
+     * May be called more than once, handle this with care
+     * (or use {@link BaseStorageDriver} that handles this for you)
+     */
+    load?: () => MaybePromise<void>;
+    /**
+     * Save session to some external storage.
+     * Should be used to commit pending changes in the session.
+     * For example, saving session content to file/network/etc,
+     * or committing a database transaction
+     *
+     * It is safe to batch all changes and only commit them here,
+     * unless stated otherwise in the method description
+     */
+    save?: () => MaybePromise<void>;
+    /**
+     * Cleanup session and release all used resources.
+     *
+     * May be called more than once, handle this with care
+     * (or use {@link BaseStorageDriver} that handles this for you)
+     */
+    destroy?: () => MaybePromise<void>;
+    /**
+     * Setup the driver, passing the logger instance,
+     * in case your driver needs it
+     */
+    setup?: (log: Logger, platform: ICorePlatform) => void;
+}
+/**
+ * Base storage driver class, implementing {@link IStorageDriver}
+ * and handling the lifecycle for you
+ */
+export declare abstract class BaseStorageDriver implements IStorageDriver {
+    abstract _load(): MaybePromise<void>;
+    abstract _destroy(): MaybePromise<void>;
+    abstract _save?(): MaybePromise<void>;
+    private _loadedTimes;
+    private _destroyed;
+    protected _log: Logger;
+    protected _platform: ICorePlatform;
+    setup(log: Logger, platform: ICorePlatform): void;
+    protected get loaded(): boolean;
+    load(): Promise<void>;
+    destroy(): Promise<void>;
+    save(): MaybePromise<void>;
+}

package/storage/index.d.cts

@@ -0,0 +1,6 @@
+export * from './driver.js';
+export * from './memory/index.js';
+export * from './provider.js';
+export * from './repository/index.js';
+export * from './sqlite/index.js';
+export * from './storage.js';

package/storage/memory/driver.d.cts

@@ -0,0 +1,6 @@
+import { IStorageDriver } from '../driver.js';
+export declare class MemoryStorageDriver implements IStorageDriver {
+    readonly states: Map<string, object>;
+    getState<T extends object>(repo: string, def: () => T): T;
+    load(): void;
+}

package/storage/memory/index.d.cts

@@ -0,0 +1,22 @@
+import { ITelegramStorageProvider } from '../../highlevel/storage/provider.js';
+import { IMtStorageProvider } from '../provider.js';
+import { MemoryStorageDriver } from './driver.js';
+import { MemoryAuthKeysRepository } from './repository/auth-keys.js';
+import { MemoryKeyValueRepository } from './repository/kv.js';
+import { MemoryPeersRepository } from './repository/peers.js';
+import { MemoryRefMessagesRepository } from './repository/ref-messages.js';
+export { MemoryStorageDriver } from './driver.js';
+/**
+ * In-memory storage driver implementation for mtcute.
+ *
+ * This storage is **not persistent**, meaning that all data
+ * **will** be lost on restart. Only use this storage for testing,
+ * or if you know exactly what you're doing.
+ */
+export declare class MemoryStorage implements IMtStorageProvider, ITelegramStorageProvider {
+    readonly driver: MemoryStorageDriver;
+    readonly kv: MemoryKeyValueRepository;
+    readonly authKeys: MemoryAuthKeysRepository;
+    readonly peers: MemoryPeersRepository;
+    readonly refMessages: MemoryRefMessagesRepository;
+}

package/storage/memory/memory.test.d.cts

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

package/storage/memory/repository/auth-keys.d.cts

@@ -0,0 +1,19 @@
+import { IAuthKeysRepository } from '../../repository/auth-keys.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface AuthKeysState {
+    authKeys: Map<number, Uint8Array>;
+    authKeysTemp: Map<string, Uint8Array>;
+    authKeysTempExpiry: Map<string, number>;
+}
+export declare class MemoryAuthKeysRepository implements IAuthKeysRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: AuthKeysState;
+    constructor(_driver: MemoryStorageDriver);
+    set(dc: number, key: Uint8Array | null): void;
+    get(dc: number): Uint8Array | null;
+    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): void;
+    getTemp(dc: number, idx: number, now: number): Uint8Array | null;
+    deleteByDc(dc: number): void;
+    deleteAll(): void;
+}
+export {};

package/storage/memory/repository/kv.d.cts

@@ -0,0 +1,11 @@
+import { IKeyValueRepository } from '../../repository/key-value.js';
+import { MemoryStorageDriver } from '../driver.js';
+export declare class MemoryKeyValueRepository implements IKeyValueRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: Map<string, Uint8Array>;
+    constructor(_driver: MemoryStorageDriver);
+    set(key: string, value: Uint8Array): void;
+    get(key: string): Uint8Array | null;
+    delete(key: string): void;
+    deleteAll(): void;
+}

package/storage/memory/repository/peers.d.cts

@@ -0,0 +1,18 @@
+import { IPeersRepository } from '../../../highlevel/storage/repository/peers.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface PeersState {
+    entities: Map<number, IPeersRepository.PeerInfo>;
+    usernameIndex: Map<string, number>;
+    phoneIndex: Map<string, number>;
+}
+export declare class MemoryPeersRepository implements IPeersRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: PeersState;
+    constructor(_driver: MemoryStorageDriver);
+    store(peer: IPeersRepository.PeerInfo): void;
+    getById(id: number, allowMin: boolean): IPeersRepository.PeerInfo | null;
+    getByUsername(username: string): IPeersRepository.PeerInfo | null;
+    getByPhone(phone: string): IPeersRepository.PeerInfo | null;
+    deleteAll(): void;
+}
+export {};

package/storage/memory/repository/ref-messages.d.cts

@@ -0,0 +1,16 @@
+import { IReferenceMessagesRepository } from '../../../highlevel/storage/repository/ref-messages.js';
+import { MemoryStorageDriver } from '../driver.js';
+interface RefMessagesState {
+    refs: Map<number, Set<string>>;
+}
+export declare class MemoryRefMessagesRepository implements IReferenceMessagesRepository {
+    readonly _driver: MemoryStorageDriver;
+    readonly state: RefMessagesState;
+    constructor(_driver: MemoryStorageDriver);
+    store(peerId: number, chatId: number, msgId: number): void;
+    getByPeer(peerId: number): [number, number] | null;
+    delete(chatId: number, msgIds: number[]): void;
+    deleteByPeer(peerId: number): void;
+    deleteAll(): void;
+}
+export {};

package/storage/provider.d.cts

@@ -0,0 +1,10 @@
+import { IStorageDriver } from './driver.js';
+import { IAuthKeysRepository } from './repository/auth-keys.js';
+import { IKeyValueRepository } from './repository/key-value.js';
+export type IStorageProvider<T> = T & {
+    readonly driver: IStorageDriver;
+};
+export type IMtStorageProvider = IStorageProvider<{
+    readonly kv: IKeyValueRepository;
+    readonly authKeys: IAuthKeysRepository;
+}>;

package/storage/repository/auth-keys.d.cts

@@ -0,0 +1,41 @@
+import { MaybePromise } from '../../types/utils.js';
+export interface IAuthKeysRepository {
+    /**
+     * Store auth_key for the given DC
+     *
+     * If `key` is `null`, the key should be deleted instead
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    set: (dc: number, key: Uint8Array | null) => MaybePromise<void>;
+    /** Get auth_key for the given DC */
+    get: (dc: number) => MaybePromise<Uint8Array | null>;
+    /**
+     * Store temp_auth_key for the given DC and idx,
+     * along with its expiration date (in seconds)
+     *
+     * If `key` is `null`, the key should be deleted instead
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    setTemp: (dc: number, idx: number, key: Uint8Array | null, expires: number) => MaybePromise<void>;
+    /**
+     * Given the DC id, idx and point in time (in seconds),
+     * return the temp_auth_key that should be used for the next request
+     * (such that `now < key.expires`), or `null` if no such key exists
+     */
+    getTemp: (dc: number, idx: number, now: number) => MaybePromise<Uint8Array | null>;
+    /**
+     * Delete all stored auth keys for the given DC, including
+     * both permanent and temp keys
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    deleteByDc: (dc: number) => MaybePromise<void>;
+    /**
+     * Delete all stored auth keys, including both permanent and temp keys
+     *
+     * **MUST** be applied immediately, without batching
+     */
+    deleteAll: () => MaybePromise<void>;
+}

package/storage/repository/index.d.cts

@@ -0,0 +1,2 @@
+export * from './auth-keys.js';
+export * from './key-value.js';

package/storage/repository/key-value.d.cts

@@ -0,0 +1,10 @@
+import { MaybePromise } from '../../types/utils.js';
+export interface IKeyValueRepository {
+    /** Set a key-value pair */
+    set: (key: string, value: Uint8Array) => MaybePromise<void>;
+    /** Get a key-value pair */
+    get: (key: string) => MaybePromise<Uint8Array | null>;
+    /** Delete a key-value pair */
+    delete: (key: string) => MaybePromise<void>;
+    deleteAll: () => MaybePromise<void>;
+}

package/storage/service/auth-keys.d.cts

@@ -0,0 +1,9 @@
+import { IAuthKeysRepository } from '../repository/auth-keys.js';
+import { ServiceOptions, BaseService } from './base.js';
+import { FutureSaltsService } from './future-salts.js';
+export declare class AuthKeysService extends BaseService {
+    readonly _keys: IAuthKeysRepository;
+    readonly _salts: FutureSaltsService;
+    constructor(_keys: IAuthKeysRepository, _salts: FutureSaltsService, opts: ServiceOptions);
+    deleteByDc(dc: number): Promise<void>;
+}

package/storage/service/auth-keys.test.d.cts

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