feat: updated to layer 186

packages/core/scripts/generate-client.cjs

@@ -736,6 +736,7 @@ withParams(params: RpcCallOptions): this\n`)
         'onConnectionState',
         'getServerUpdateHandler',
         'changePrimaryDc',
+        'getMtprotoMessageId',
     ].forEach((name) => {
         output.write(
             `TelegramClient.prototype.${name} = function(...args) {\n`

packages/core/src/highlevel/base.ts

@@ -1,5 +1,6 @@
 import type { mtp } from '@mtcute/tl'
 import { tl } from '@mtcute/tl'
+import type Long from 'long'
 
 import type { MtClientOptions } from '../network/client.js'
 import { MtClient } from '../network/client.js'
@@ -368,4 +369,8 @@ export class BaseTelegramClient implements ITelegramClient {
     changePrimaryDc(dcId: number): Promise<void> {
         return this.mt.network.changePrimaryDc(dcId)
     }
+
+    async getMtprotoMessageId(): Promise<Long> {
+        return this.mt.network.getMtprotoMessageId()
+    }
 }

packages/core/src/highlevel/client.ts

@@ -186,6 +186,7 @@ import type { SendCopyParams } from './methods/messages/send-copy.js'
 import { sendCopy } from './methods/messages/send-copy.js'
 import { sendMediaGroup } from './methods/messages/send-media-group.js'
 import { sendMedia } from './methods/messages/send-media.js'
+import { sendPaidReaction } from './methods/messages/send-paid-reaction.js'
 import type { QuoteParamsFrom } from './methods/messages/send-quote.js'
 import { quoteWithMedia, quoteWithMediaGroup, quoteWithText } from './methods/messages/send-quote.js'
 import { sendReaction } from './methods/messages/send-reaction.js'
@@ -519,6 +520,7 @@ export interface TelegramClient extends ITelegramClient {
      */
     on(name: 'delete_business_message', handler: ((upd: DeleteBusinessMessageUpdate) => void)): this
 
+    // eslint-disable-next-line ts/no-explicit-any
     on(name: string, handler: (...args: any[]) => void): this
 
     /**
@@ -4153,6 +4155,34 @@ export interface TelegramClient extends ITelegramClient {
              */
             progressCallback?: (uploaded: number, total: number) => void
         }): Promise<Message>
+
+    /**
+     * Send a paid reaction using Telegram Stars.
+     *
+     * **Available**: 👤 users only
+     *
+     * @returns
+     *   Message to which the reaction was sent, if available.
+     *   The message is normally available for users, but may not be available for bots in PMs.
+     */
+    sendPaidReaction(
+        params: InputMessageId & {
+        /** Whether to send the reaction anonymously */
+            anonymous?: boolean
+
+            /**
+             * Number of reactions to send
+             *
+             * @default  1
+             */
+            count?: number
+
+            /**
+             * Whether to dispatch the returned edit message event
+             * to the client's update handler.
+             */
+            shouldDispatch?: true
+        }): Promise<MessageReactions>
     /** Send a text in reply to a given quote */
     quoteWithText(
         message: Message,
@@ -6179,6 +6209,9 @@ TelegramClient.prototype.sendMediaGroup = function (...args) {
 TelegramClient.prototype.sendMedia = function (...args) {
     return sendMedia(this._client, ...args)
 }
+TelegramClient.prototype.sendPaidReaction = function (...args) {
+    return sendPaidReaction(this._client, ...args)
+}
 TelegramClient.prototype.quoteWithText = function (...args) {
     return quoteWithText(this._client, ...args)
 }
@@ -6532,6 +6565,9 @@ TelegramClient.prototype.getServerUpdateHandler = function (...args) {
 TelegramClient.prototype.changePrimaryDc = function (...args) {
     return this._client.changePrimaryDc(...args)
 }
+TelegramClient.prototype.getMtprotoMessageId = function (...args) {
+    return this._client.getMtprotoMessageId(...args)
+}
 TelegramClient.prototype.onServerUpdate = function () {
     throw new Error('onServerUpdate is not available for TelegramClient, use .on() methods instead')
 }

packages/core/src/highlevel/client.types.ts

@@ -1,4 +1,5 @@
 import type { tl } from '@mtcute/tl'
+import type Long from 'long'
 
 import type { ConnectionKind, RpcCallOptions } from '../network/index.js'
 import type { MustEqual, PublicPart } from '../types/utils.js'
@@ -69,4 +70,5 @@ export interface ITelegramClient {
 
     computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>
     computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>
+    getMtprotoMessageId(): Promise<Long>
 }

packages/core/src/highlevel/methods.ts

@@ -176,6 +176,7 @@ export { sendCopy } from './methods/messages/send-copy.js'
 export type { SendCopyParams } from './methods/messages/send-copy.js'
 export { sendMediaGroup } from './methods/messages/send-media-group.js'
 export { sendMedia } from './methods/messages/send-media.js'
+export { sendPaidReaction } from './methods/messages/send-paid-reaction.js'
 export { quoteWithText } from './methods/messages/send-quote.js'
 export type { QuoteParamsFrom } from './methods/messages/send-quote.js'
 export { quoteWithMedia } from './methods/messages/send-quote.js'

packages/core/src/highlevel/methods/messages/send-paid-reaction.ts

@@ -0,0 +1,89 @@
+import { tl } from '@mtcute/tl'
+
+import type { ITelegramClient } from '../../client.types.js'
+import type {
+    InputMessageId,
+} from '../../types/index.js'
+import {
+    MessageReactions,
+
+    PeersIndex,
+    normalizeInputMessageId,
+} from '../../types/index.js'
+import { assertIsUpdatesGroup } from '../../updates/utils.js'
+import { resolvePeer } from '../users/resolve-peer.js'
+import { MtcuteError } from '../../../types/errors.js'
+import { assertTypeIs } from '../../../utils/type-assertions.js'
+import { getMarkedPeerId } from '../../../utils/peer-utils.js'
+
+// @available=user
+/**
+ * Send a paid reaction using Telegram Stars.
+ *
+ * @returns
+ *   Message to which the reaction was sent, if available.
+ *   The message is normally available for users, but may not be available for bots in PMs.
+ */
+export async function sendPaidReaction(
+    client: ITelegramClient,
+    params: InputMessageId & {
+        /** Whether to send the reaction anonymously */
+        anonymous?: boolean
+
+        /**
+         * Number of reactions to send
+         *
+         * @default  1
+         */
+        count?: number
+
+        /**
+         * Whether to dispatch the returned edit message event
+         * to the client's update handler.
+         */
+        shouldDispatch?: true
+    },
+): Promise<MessageReactions> {
+    const { anonymous, count = 1 } = params
+    const { chatId, message } = normalizeInputMessageId(params)
+
+    const peer = await resolvePeer(client, chatId)
+
+    let res
+
+    for (let i = 0; i < 3; i++) {
+        try {
+            res = await client.call({
+                _: 'messages.sendPaidReaction',
+                peer,
+                msgId: message,
+                count,
+                private: anonymous,
+                randomId: await client.getMtprotoMessageId(),
+            })
+            break
+        } catch (e) {
+            if (tl.RpcError.is(e, 'RANDOM_ID_EXPIRED')) {
+                // just retry, mtproto message id may have been stale
+                continue
+            }
+
+            throw e
+        }
+    }
+
+    if (!res) {
+        throw new MtcuteError('Could not send paid reaction')
+    }
+
+    assertIsUpdatesGroup('messages.sendReaction', res)
+
+    // normally the group only contains updateMessageReactions
+
+    const peers = PeersIndex.from(res)
+    const upd = res.updates[0]
+
+    assertTypeIs('messages.sendPaidReaction (@ .updates[0])', upd, 'updateMessageReactions')
+
+    return new MessageReactions(upd.msgId, getMarkedPeerId(upd.peer), upd.reactions, peers)
+}

packages/core/src/highlevel/types/messages/message-reactions.ts

@@ -3,7 +3,7 @@ import type { tl } from '@mtcute/tl'
 import { makeInspectable } from '../../utils/index.js'
 import { memoizeGetters } from '../../utils/memoize.js'
 import type { PeersIndex } from '../peers/index.js'
-import { PeerReaction } from '../reactions/peer-reaction.js'
+import { PaidPeerReaction, PeerReaction } from '../reactions/peer-reaction.js'
 import { ReactionCount } from '../reactions/reaction-count.js'
 
 /**
@@ -40,6 +40,11 @@ export class MessageReactions {
     get recentReactions(): PeerReaction[] {
         return this.raw.recentReactions?.map(reaction => new PeerReaction(reaction, this._peers)) ?? []
     }
+
+    /** Leaderboard of paid reactions to the message */
+    get paidReactions(): PaidPeerReaction[] {
+        return this.raw.topReactors?.map(reaction => new PaidPeerReaction(reaction, this._peers)) ?? []
+    }
 }
 
 memoizeGetters(MessageReactions, ['reactions', 'recentReactions'])

packages/core/src/highlevel/types/peers/chat-event/actions.ts

@@ -354,6 +354,14 @@ export interface ChatActionTopicDeleted {
     topic: ForumTopic
 }
 
+/** Profile signatures were toggled in a channel ("Super Channel" mode) */
+export interface ChatActionSignatureProfilesToggled {
+    type: 'signature_profiles_toggled'
+
+    /** Whether signatures are enabled as of this action */
+    new: boolean
+}
+
 /** Chat event action (`null` if unsupported) */
 export type ChatAction =
   | ChatActionUserJoined
@@ -392,6 +400,7 @@ export type ChatAction =
   | ChatActionTopicCreated
   | ChatActionTopicEdited
   | ChatActionTopicDeleted
+  | ChatActionSignatureProfilesToggled
   | null
 
 /** @internal */
@@ -613,6 +622,11 @@ export function _actionFromTl(e: tl.TypeChannelAdminLogEventAction, peers: Peers
             }
         // case 'channelAdminLogEventActionPinTopic'
         // ^ looks like it is not used, and pinned topics are not at all presented in the event log
+        case 'channelAdminLogEventActionToggleSignatureProfiles':
+            return {
+                type: 'signature_profiles_toggled',
+                new: e.newValue,
+            }
         default:
             return null
     }

packages/core/src/highlevel/types/peers/chat-event/filters.ts

@@ -63,6 +63,7 @@ export function normalizeChatEventFilters(input: InputChatEventFilters): ChatEve
                 case 'def_perms_changed':
                 case 'forum_toggled':
                 case 'no_forwards_toggled':
+                case 'signature_profiles_toggled':
                     serverFilter.settings = true
                     break
                 case 'msg_pinned':

packages/core/src/highlevel/types/peers/chat-member.ts

@@ -175,6 +175,22 @@ export class ChatMember {
                 return null
         }
     }
+
+    /**
+     * If this member subscribed to a channel using Telegram Stars,
+     * this field will contain the date when the subscription will expire
+     */
+    get subscriptionUntilDate(): Date | null {
+        switch (this.raw._) {
+            case 'channelParticipant':
+            case 'channelParticipantSelf':
+                if (!this.raw.subscriptionUntilDate) return null
+
+                return new Date(this.raw.subscriptionUntilDate * 1000)
+        }
+
+        return null
+    }
 }
 
 memoizeGetters(ChatMember, ['user', 'invitedBy', 'promotedBy', 'restrictedBy', 'restrictions'])

packages/core/src/highlevel/types/peers/chat.ts

@@ -284,6 +284,11 @@ export class Chat {
         return (this.peer._ === 'channel' || this.peer._ === 'chat') && this.peer.noforwards!
     }
 
+    /** Whether this channel has profile signatures (i.e. "Super Channel") */
+    get hasProfileSignatures(): boolean {
+        return this.peer._ === 'channel' && this.peer.signatureProfiles!
+    }
+
     /**
      * Title, for supergroups, channels and groups
      */
@@ -487,6 +492,16 @@ export class Chat {
         return new User(this.peer)
     }
 
+    /**
+     * If a subscription to this channel was bought using Telegram Stars,
+     * this field will contain the date when the subscription will expire.
+     */
+    get subscriptionUntilDate(): Date | null {
+        if (this.peer._ !== 'channel' || !this.peer.subscriptionUntilDate) return null
+
+        return new Date(this.peer.subscriptionUntilDate * 1000)
+    }
+
     /** @internal */
     static _parseFromMessage(message: tl.RawMessage | tl.RawMessageService, peers: PeersIndex): Chat {
         return Chat._parseFromPeer(message.peerId, peers)

packages/core/src/highlevel/types/peers/full-chat.ts

@@ -62,6 +62,11 @@ export class FullChat extends Chat {
         return this.fullPeer?._ === 'userFull' && this.fullPeer.voiceMessagesForbidden!
     }
 
+    /** Whether paid reactions are enabled for this channel */
+    get hasPaidReactions(): boolean {
+        return this.fullPeer?._ === 'channelFull' && this.fullPeer.paidReactionsAvailable!
+    }
+
     /**
      * Full information about this chat's photo, if any.
      *

packages/core/src/highlevel/types/reactions/peer-reaction.ts

@@ -6,6 +6,7 @@ import { makeInspectable } from '../../utils/index.js'
 import { memoizeGetters } from '../../utils/memoize.js'
 import type { PeersIndex } from '../peers/peers-index.js'
 import { User } from '../peers/user.js'
+import { type Peer, parsePeer } from '../peers/peer.js'
 
 import type { ReactionEmoji } from './types.js'
 import { toReactionEmoji } from './types.js'
@@ -59,3 +60,41 @@ export class PeerReaction {
 
 memoizeGetters(PeerReaction, ['user'])
 makeInspectable(PeerReaction)
+
+/**
+ * Information about paid reactions of a single user to a message,
+ * currently only used for a per-post leaderboard in the app.
+ */
+export class PaidPeerReaction {
+    constructor(
+        readonly raw: tl.RawMessageReactor,
+        readonly _peers: PeersIndex,
+    ) {}
+
+    /** Whether this reaction is from the current user */
+    get my(): boolean {
+        return this.raw.my!
+    }
+
+    /** Whether this reaction was sent anonymously */
+    get anonymous(): boolean {
+        return this.raw.anonymous!
+    }
+
+    /**
+     * If this reaction was not sent anonymously,
+     * this field will contain the user who sent it
+     */
+    get peer(): Peer | null {
+        if (!this.raw.peerId) return null
+        return parsePeer(this.raw.peerId, this._peers)
+    }
+
+    /** Number of reactions sent by this user */
+    get count(): number {
+        return this.raw.count
+    }
+}
+
+memoizeGetters(PaidPeerReaction, ['peer'])
+makeInspectable(PaidPeerReaction)

packages/core/src/highlevel/types/reactions/reaction-count.ts

@@ -18,6 +18,11 @@ export class ReactionCount {
         return toReactionEmoji(this.raw.reaction)
     }
 
+    /** Whether this is a paid reaction */
+    get isPaid(): boolean {
+        return this.raw.reaction._ === 'reactionPaid'
+    }
+
     /**
      * Number of users who reacted with this emoji
      */

packages/core/src/highlevel/types/reactions/types.ts

@@ -12,11 +12,19 @@ export type InputReaction = string | tl.Long | tl.TypeReaction
  * Emoji describing a reaction.
  *
  * Either a `string` with a unicode emoji, or a `tl.Long` for a custom emoji
+ *
+ * For paid reactions, will always contain `⭐` emoji
  */
 export type ReactionEmoji = string | tl.Long
 
 export function normalizeInputReaction(reaction?: InputReaction | null): tl.TypeReaction {
     if (typeof reaction === 'string') {
+        if (reaction === 'paid') {
+            return {
+                _: 'reactionPaid',
+            }
+        }
+
         return {
             _: 'reactionEmoji',
             emoticon: reaction,
@@ -44,6 +52,8 @@ export function toReactionEmoji(reaction: tl.TypeReaction, allowEmpty?: boolean)
             return reaction.emoticon
         case 'reactionCustomEmoji':
             return reaction.documentId
+        case 'reactionPaid':
+            return '⭐'
         case 'reactionEmpty':
             if (!allowEmpty) {
                 throw new MtTypeAssertionError('toReactionEmoji', 'not reactionEmpty', reaction._)

packages/core/src/highlevel/worker/port.ts

@@ -45,6 +45,7 @@ export abstract class TelegramWorkerPort<Custom extends WorkerCustomMethods> imp
     readonly computeNewPasswordHash: ITelegramClient['computeNewPasswordHash']
     readonly startUpdatesLoop: ITelegramClient['startUpdatesLoop']
     readonly stopUpdatesLoop: ITelegramClient['stopUpdatesLoop']
+    readonly getMtprotoMessageId: ITelegramClient['getMtprotoMessageId']
 
     private _abortController = new AbortController()
     readonly stopSignal: AbortSignal = this._abortController.signal
@@ -79,6 +80,7 @@ export abstract class TelegramWorkerPort<Custom extends WorkerCustomMethods> imp
         this.computeNewPasswordHash = bind('computeNewPasswordHash')
         this.startUpdatesLoop = bind('startUpdatesLoop')
         this.stopUpdatesLoop = bind('stopUpdatesLoop')
+        this.getMtprotoMessageId = bind('getMtprotoMessageId')
     }
 
     call<T extends tl.RpcMethod>(

packages/core/src/network/network-manager.ts

@@ -1,5 +1,6 @@
 import type { mtp, tl } from '@mtcute/tl'
 import type { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime'
+import type Long from 'long'
 
 import { getPlatform } from '../platform.js'
 import type { StorageManager } from '../storage/storage.js'
@@ -896,4 +897,8 @@ export class NetworkManager {
         this.config.offReload(this._onConfigChanged)
         this._resetOnNetworkChange?.()
     }
+
+    getMtprotoMessageId(): Long {
+        return this._primaryDc!.main._sessions[0].getMessageId()
+    }
 }

packages/tl/README.md

@@ -2,7 +2,7 @@
 
 TL schema and related utils used for mtcute.
 
-Generated from TL layer **185** (last updated on 07.08.2024).
+Generated from TL layer **186** (last updated on 18.08.2024).
 
 ## About
 

packages/tl/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mtcute/tl",
-  "version": "185.1.0",
+    "version": "186.0.0",
     "description": "TL schema used for mtcute",
     "author": "alina sireneva <alina@tei.su>",
     "license": "MIT",