Class TelegramWorkerPort<Custom>Abstract

Type Parameters

Hierarchy (View Summary)

Implements

Constructors

constructor

Properties

appConfig changePrimaryDc computeNewPasswordHash computeSrpParams destroy_ disconnect exportSession getApiCredentials getMtprotoMessageId getPoolSize getPrimaryDcId handleClientUpdate importSession log notifyChannelClosed notifyChannelOpened notifyLoggedIn notifyLoggedOut onConnectionState onError onRawUpdate onServerUpdate options platform prepare recreateDc startUpdatesLoop stopSignal stopUpdatesLoop storage timers workerId

Methods

call connect connectToWorker destroy invokeCustom

Constructors

constructor

Properties

ReadonlyappConfig

appConfig: AppConfigManagerProxy

App config manager

ReadonlychangePrimaryDc

changePrimaryDc: (newDc: number) => Promise<void>

Change the primary DC

ReadonlycomputeNewPasswordHash

computeNewPasswordHash: (
    algo: TypePasswordKdfAlgo,
    password: string,
) => Promise<Uint8Array>

Compute new password hash for the given algorithm and password

ReadonlycomputeSrpParams

computeSrpParams: (
    request: RawPassword,
    password: string,
) => Promise<RawInputCheckPasswordSRP>

Compute SRP parameters for the given password

Readonlydestroy_

destroy_: () => Promise<void>

Type declaration

    • (): Promise<void>

    • Destroy the client and all its resources.

      This will terminate any connections to the Telegram servers, free all the resources, and make the client no longer usable

      Returns Promise<void>

Readonlydisconnect

disconnect: () => Promise<void>

Terminate any connections to the Telegram servers, but keep the client usable

ReadonlyexportSession

exportSession: () => Promise<string>

Export current session to a single LONG string, containing all the needed information.

Warning! Anyone with this string will be able to authorize as you and do anything. Treat this as your password, and never give it away!

In case you have accidentally leaked this string, make sure to revoke this session in account settings: "Privacy & Security" > "Active sessions" > find the one containing mtcute > Revoke, or, in case this is a bot, revoke bot token with @BotFather

ReadonlygetApiCredentials

getApiCredentials: () => Promise<{ hash: string; id: number }>

Get the API credentials for use in authorization methods

ReadonlygetMtprotoMessageId

getMtprotoMessageId: () => Promise<Long>

Generate a new time-based MTProto message ID

ReadonlygetPoolSize

getPoolSize: (kind: ConnectionKind, dcId?: number) => Promise<number>

Get the number of connections of the given kind

ReadonlygetPrimaryDcId

getPrimaryDcId: () => Promise<number>

Get the primary DC ID

ReadonlyhandleClientUpdate

handleClientUpdate: (updates: TypeUpdates, noDispatch?: boolean) => void

Handle an update sent by the server in response to an RPC call

Type declaration

    • (updates: TypeUpdates, noDispatch?: boolean): void

    • Parameters

      • updates: TypeUpdates

        Updates to handle

      • OptionalnoDispatch: boolean

        Whether the updates inside should not be dispatched as events

      Returns void

ReadonlyimportSession

importSession: (
    session: string | InputStringSessionData,
    force?: boolean,
) => Promise<void>

Import the session from the given session string.

Note that the session will only be imported in case the storage is missing authorization (i.e. does not contain auth key for the primary DC), otherwise it will be ignored (unless force).

Type declaration

    • (session: string | InputStringSessionData, force?: boolean): Promise<void>

    • Parameters

      • session: string | InputStringSessionData

        Session string to import

      • Optionalforce: boolean

        Whether to overwrite existing session

      Returns Promise<void>

Readonlylog

log: LogManager

Logger for the client

ReadonlynotifyChannelClosed

notifyChannelClosed: (channelId: number) => Promise<boolean>

Notify the client that a channel has been closed

ReadonlynotifyChannelOpened

notifyChannelOpened: (channelId: number, pts?: number) => Promise<boolean>

Notify the client that a channel has been opened

ReadonlynotifyLoggedIn

notifyLoggedIn: (auth: RawUser | TypeAuthorization) => Promise<RawUser>

Notify the client that the user has logged in

ReadonlynotifyLoggedOut

notifyLoggedOut: () => Promise<void>

Notify the client that the user has logged out

onConnectionState

onConnectionState: Emitter<ConnectionState> = ...

Emitted when the connection state changes

onError

onError: Emitter<Error> = ...

Emitted when an error occurs

onRawUpdate

onRawUpdate: Emitter<RawUpdateInfo> = ...

Emitted when an update is received from the server. Requires updates loop to be running

onServerUpdate

onServerUpdate: Emitter<TypeUpdates> = ...

Emitted when a low-level Updates updates is received

Readonlyoptions

options: TelegramWorkerPortOptions

Readonlyplatform

platform: ICorePlatform

Platform used by the client

Readonlyprepare

prepare: () => Promise<void>

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 connect to actually connect.

ReadonlyrecreateDc

recreateDc: (dcId: number) => Promise<void>

ADVANCED Recreate the given DC, forcefully using the IP taken from server config.

ReadonlystartUpdatesLoop

startUpdatesLoop: () => Promise<void>

Start the updates loop

ReadonlystopSignal

stopSignal: AbortSignal = ...

Signal that will be aborted when the client is destroyed

ReadonlystopUpdatesLoop

stopUpdatesLoop: () => Promise<void>

Stop the updates loop

Readonlystorage

storage: TelegramStorageProxy

Storage manager

Readonlytimers

timers: TimersManager

Timers manager

ReadonlyworkerId

workerId: string

Methods

call

  • call<T extends RpcMethod>(
        message: MustEqual<T, RpcMethod>,
        params?: RpcCallOptions,
    ): Promise<RpcCallReturn[T["_"]]>

  • Call an RPC method

    Type Parameters

    • T extends RpcMethod

    Parameters

    Returns Promise<RpcCallReturn[T["_"]]>

connect

  • connect(): Promise<void>

  • 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 call.

    Returns Promise<void>

AbstractconnectToWorker

destroy

  • destroy(terminate?: boolean): Promise<void>

  • Destroy the client and all its resources.

    This will terminate any connections to the Telegram servers, free all the resources, and make the client no longer usable

    Parameters

    • terminate: boolean = false

    Returns Promise<void>

invokeCustom

  • invokeCustom<T extends string | number | symbol>(
        method: T,
        ...args: Parameters<Custom[T]>,
    ): Promise<ReturnType<Custom[T]>>

  • Type Parameters

    • T extends string | number | symbol

    Parameters

    Returns Promise<ReturnType<Custom[T]>>

Settings

Member Visibility

On This Page

Constructors
Properties
Methods