mtproto 0.0.19 → 0.0.20

data/lib/mtproto/tl/objects/bot_callback_answer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.botCallbackAnswer — the reply to messages.getBotCallbackAnswer: the
+    # answer the pressed bot produced via setBotCallbackAnswer (or the server's
+    # empty default when the bot never answered). `message` is the toast/alert
+    # text, `alert` selects a modal over a toast, `url` (paired with `has_url`) is a
+    # game/redirect link, `native_ui` marks a Telegram-native prompt, and
+    # `cache_time` is how long the client may cache this answer.
+    class BotCallbackAnswer
+      CONSTRUCTOR = 0x36585ea4
+
+      attr_reader :alert, :has_url, :native_ui, :message, :url, :cache_time
+
+      def initialize(alert: false, has_url: false, native_ui: false, message: nil, url: nil, cache_time: 0)
+        @alert = alert
+        @has_url = has_url
+        @native_ui = native_ui
+        @message = message
+        @url = url
+        @cache_time = cache_time
+      end
+
+      # messages.botCallbackAnswer#36585ea4 flags:# alert:flags.1?true
+      #   has_url:flags.3?true native_ui:flags.4?true message:flags.0?string
+      #   url:flags.2?string cache_time:int
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        unless constructor == CONSTRUCTOR
+          raise "Expected botCallbackAnswer constructor, got 0x#{constructor.to_s(16)}"
+        end
+
+        flags = data[4, 4].unpack1('L<')
+        offset = 8
+
+        message = nil
+        message, offset = read_tl_string(data, offset) if flags.anybits?(1 << 0)
+
+        url = nil
+        url, offset = read_tl_string(data, offset) if flags.anybits?(1 << 2)
+
+        cache_time = data[offset, 4].unpack1('l<')
+
+        new(
+          alert: flags.anybits?(1 << 1),
+          has_url: flags.anybits?(1 << 3),
+          native_ui: flags.anybits?(1 << 4),
+          message: message,
+          url: url,
+          cache_time: cache_time
+        )
+      end
+
+      class << self
+        private
+
+        def read_tl_string(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte == 254
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          else
+            len = first_byte
+            total = 1 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [data[offset + (total - len), len].force_encoding('UTF-8'), offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/channel_difference.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative '../schema'
+require_relative 'message'
+require_relative 'dialogs'
+
+module MTProto
+  module TL
+    # updates.ChannelDifference — the reply to updates.getChannelDifference: a
+    # channel/supergroup's backlog since a given pts. Channels aren't pushed to a
+    # fresh session, so the client pulls this. Three variants:
+    #   channelDifference        — new_messages + other_updates + chats + users, with the new pts
+    #   channelDifferenceEmpty   — nothing new since pts (just pts/final/timeout)
+    #   channelDifferenceTooLong — gap too large: a Dialog snapshot + a messages slice
+    #                              + chats + users; the caller resyncs pts from the dialog
+    # Mirrors UpdatesDifference: reads only the surfaced fields and advances the rest
+    # via Schema#skip (zero-drop, robust to an unmodelled tail).
+    class ChannelDifference
+      attr_reader :type, :final, :pts, :timeout, :new_messages, :chats, :users
+
+      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
+
+      # Channel messages ride in new_messages, but message-bearing updates can also
+      # appear in other_updates — mine those too, like UpdatesDifference.
+      UPDATE_NEW_MESSAGE = 0x1f2b0afd
+      UPDATE_NEW_CHANNEL_MESSAGE = 0x62ba04d9
+
+      def initialize(type:, final: false, pts: nil, timeout: nil, new_messages: [], chats: [], users: [])
+        @type = type
+        @final = final
+        @pts = pts
+        @timeout = timeout
+        @new_messages = new_messages
+        @chats = chats
+        @users = users
+      end
+
+      def self.schema
+        @schema ||= Schema.new(SCHEMA_PATH)
+      end
+
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        case constructor
+        when Constructors::UPDATES_CHANNEL_DIFFERENCE_EMPTY
+          parse_empty(data)
+        when Constructors::UPDATES_CHANNEL_DIFFERENCE
+          parse_difference(data)
+        when Constructors::UPDATES_CHANNEL_DIFFERENCE_TOO_LONG
+          parse_too_long(data)
+        else
+          warn "Unknown ChannelDifference constructor: 0x#{constructor.to_s(16)}, treating as empty"
+          new(type: :empty, final: true)
+        end
+      end
+
+      class << self
+        private
+
+        # channelDifferenceEmpty#3e11affb flags:# final:flags.0?true pts:int timeout:flags.1?int
+        def parse_empty(data)
+          flags = data[4, 4].unpack1('L<')
+          timeout = data[12, 4].unpack1('L<') if flags.anybits?(1 << 1)
+          new(type: :empty, final: flags.anybits?(1 << 0), pts: data[8, 4].unpack1('L<'), timeout: timeout)
+        end
+
+        # channelDifference#2064674e flags:# final:flags.0?true pts:int timeout:flags.1?int
+        #   new_messages:Vector<Message> other_updates:Vector<Update> chats:Vector<Chat> users:Vector<User>
+        def parse_difference(data)
+          flags = data[4, 4].unpack1('L<')
+          pts = data[8, 4].unpack1('L<')
+          offset = 12
+          timeout = nil
+          if flags.anybits?(1 << 1)
+            timeout = data[offset, 4].unpack1('L<')
+            offset += 4
+          end
+
+          messages, offset = parse_messages_vector(data, offset)
+          other_messages, offset = parse_other_updates(data, offset)
+          chats, offset = Dialogs.chats_at(data, offset)
+          users, = Dialogs.users_at(data, offset)
+
+          new(
+            type: :difference,
+            final: flags.anybits?(1 << 0),
+            pts: pts,
+            timeout: timeout,
+            new_messages: messages + other_messages,
+            chats: chats,
+            users: users
+          )
+        end
+
+        # channelDifferenceTooLong#a4bcc6fe flags:# final:flags.0?true timeout:flags.1?int
+        #   dialog:Dialog messages:Vector<Message> chats:Vector<Chat> users:Vector<User>
+        # No inline pts: the fresh Dialog carries the new pts (its own flags.0). We skip
+        # the Dialog structurally and surface the messages slice + chats/users; the caller
+        # resyncs pts from the dialog before the next pull.
+        def parse_too_long(data)
+          flags = data[4, 4].unpack1('L<')
+          offset = 8
+          timeout = nil
+          if flags.anybits?(1 << 1)
+            timeout = data[offset, 4].unpack1('L<')
+            offset += 4
+          end
+
+          offset = schema.skip(data, offset) # dialog:Dialog
+          messages, offset = parse_messages_vector(data, offset)
+          chats, offset = Dialogs.chats_at(data, offset)
+          users, = Dialogs.users_at(data, offset)
+
+          new(
+            type: :too_long,
+            final: flags.anybits?(1 << 0),
+            timeout: timeout,
+            new_messages: messages,
+            chats: chats,
+            users: users
+          )
+        end
+
+        def parse_messages_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          messages = []
+          count.times do
+            constructor = data[offset, 4].unpack1('L<')
+            msg = Message.deserialize(data, offset, constructor)
+            messages << msg.to_h if msg
+            offset = schema.skip(data, offset)
+          end
+          [messages, offset]
+        end
+
+        # other_updates:Vector<Update> — mine message-bearing updates
+        # (updateNewMessage/updateNewChannelMessage: the ctor, then an inner Message,
+        # then pts/pts_count), and advance the rest via schema.
+        def parse_other_updates(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          messages = []
+          count.times do
+            ctor = data[offset, 4].unpack1('L<')
+            if [UPDATE_NEW_MESSAGE, UPDATE_NEW_CHANNEL_MESSAGE].include?(ctor)
+              inner_off = offset + 4
+              msg = Message.deserialize(data, inner_off, data[inner_off, 4].unpack1('L<'))
+              messages << msg.to_h if msg
+            end
+            offset = schema.skip(data, offset)
+          end
+          [messages, offset]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/channels_edit_banned.rb

@@ -2,18 +2,37 @@
 
 module MTProto
   module TL
+    # channels.editBanned — restrict, ban, or (with no rights) lift restrictions on
+    # a participant in a supergroup. Returns Updates.
     class ChannelsEditBanned
       include Binary
 
       CONSTRUCTOR = 0x96e6cd81
       CHAT_BANNED_RIGHTS = 0x9f120418
 
-      def initialize(channel:, participant:, view_messages: false, send_messages: false, until_date: 0)
+      # Flag bit per chatBannedRights right (the schema leaves bits 9, 11-14 and 16
+      # unused). view_messages is a full ban (can't even read); the rest restrict
+      # specific actions.
+      BANNED_RIGHT_BITS = {
+        view_messages: 0, send_messages: 1, send_media: 2, send_stickers: 3,
+        send_gifs: 4, send_games: 5, send_inline: 6, embed_links: 7, send_polls: 8,
+        change_info: 10, invite_users: 15, pin_messages: 17, manage_topics: 18,
+        send_photos: 19, send_videos: 20, send_roundvideos: 21, send_audios: 22,
+        send_voices: 23, send_docs: 24, send_plain: 25, edit_rank: 26, send_reactions: 27
+      }.freeze
+
+      # channel is { id:, access_hash: }; participant is { type:, id:, access_hash: }.
+      # Pass any BANNED_RIGHT_BITS key as true to apply that restriction (e.g.
+      # view_messages: true bans, send_messages: true mutes); none/all-false with
+      # until_date 0 lifts. until_date is the unix expiry (0 = until lifted).
+      def initialize(channel:, participant:, until_date: 0, **rights)
+        unknown = rights.keys - BANNED_RIGHT_BITS.keys
+        raise ArgumentError, "unknown banned right(s): #{unknown.join(', ')}" unless unknown.empty?
+
         @channel = channel
         @participant = participant
-        @view_messages = view_messages
-        @send_messages = send_messages
         @until_date = until_date
+        @rights = rights
       end
 
       def serialize
@@ -27,9 +46,7 @@ module MTProto
       private
 
       def serialize_banned_rights
-        flags = 0
-        flags |= (1 << 0) if @view_messages
-        flags |= (1 << 1) if @send_messages
+        flags = BANNED_RIGHT_BITS.sum { |right, bit| @rights[right] ? (1 << bit) : 0 }
         u32_b(CHAT_BANNED_RIGHTS) + u32_b(flags) + u32_b(@until_date)
       end
 

data/lib/mtproto/tl/objects/get_bot_info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # bots.getBotInfo — read a bot's name/about/description for a language.
+    # Returns bots.botInfo. Result parsing belongs to a later layer; this object
+    # only builds the request.
+    class GetBotInfo
+      include Binary
+
+      CONSTRUCTOR = 0xdcd914fd
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot: { id:, access_hash: } or { type: :self }; nil targets the calling bot
+      def initialize(bot: nil, lang_code: '')
+        @bot = bot
+        @lang_code = lang_code
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @bot
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot) if @bot
+        result += serialize_tl_string(@lang_code)
+        result
+      end
+
+      private
+
+      def serialize_input_user(user)
+        if user[:type] == :self
+          u32_b(INPUT_USER_SELF)
+        else
+          u32_b(INPUT_USER) + u64_b(user[:id]) + u64_b(user[:access_hash] || 0)
+        end
+      end
+
+      def serialize_tl_string(str)
+        bytes = str.to_s.encode('UTF-8').bytes
+        length = bytes.length
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/message.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../reader'
+require_relative '../message_entity'
 
 module MTProto
   module TL
@@ -20,7 +21,8 @@ module MTProto
       MESSAGE_FWD_HEADER = 0x4e4df4bb
 
       FIELDS = %i[id date message peer_type peer_id from_type from_id out media
-                  document photo is_reply reply_to_msg_id fwd_from_type fwd_from_id].freeze
+                  document photo is_reply reply_to_msg_id reply_to_peer_type reply_to_peer_id
+                  is_quote quote_text quote_offset entities fwd_from_type fwd_from_id].freeze
 
       attr_reader(*FIELDS)
 
@@ -63,10 +65,9 @@ module MTProto
           offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
           offset = x.schema.skip(data, offset) if flags2.anybits?(1 << 19) # guestchat_via_from (layer 227, Peer)
 
-          is_reply = false
-          reply_to_msg_id = nil
+          reply = nil
           if flags.anybits?(1 << 3) # reply_to
-            reply_to_msg_id, is_reply = x.parse_reply_to(data, offset)
+            reply = x.parse_reply_to(data, offset)
             offset = x.schema.skip(data, offset)
           end
 
@@ -77,15 +78,34 @@ module MTProto
           media = has_media ? x.parse_media(data, offset) : nil
           document = has_media ? x.parse_document(data, offset) : nil
           photo = has_media ? x.parse_photo(data, offset) : nil
+          entities = parse_entities(data, offset, flags, has_media)
 
           new(id: id, date: date, message: message_text, peer_type: peer_type, peer_id: peer_id,
             from_type: from_type, from_id: from_id, out: flags.anybits?(1 << 1),
-            media: media, document: document, photo: photo, is_reply: is_reply,
-            reply_to_msg_id: reply_to_msg_id, fwd_from_type: fwd_from_type, fwd_from_id: fwd_from_id)
+            media: media, document: document, photo: photo,
+            is_reply: reply ? reply[:is_reply] : false, reply_to_msg_id: reply && reply[:msg_id],
+            reply_to_peer_type: reply && reply[:peer_type], reply_to_peer_id: reply && reply[:peer_id],
+            is_quote: reply ? reply[:is_quote] : false, quote_text: reply && reply[:quote_text],
+            quote_offset: reply && reply[:quote_offset], entities: entities,
+            fwd_from_type: fwd_from_type, fwd_from_id: fwd_from_id)
         end
 
         private
 
+        # entities (flags.7) sit past media (flags.9) and reply_markup (flags.6) in the
+        # message tail; step over those (schema-sized) then decode the
+        # Vector<MessageEntity>. Best-effort: any misread yields [] so a message is
+        # never dropped over its formatting.
+        def parse_entities(data, offset, flags, has_media)
+          offset = x.schema.skip(data, offset) if has_media
+          offset = x.schema.skip(data, offset) if flags.anybits?(1 << 6) # reply_markup
+          return [] unless flags.anybits?(1 << 7) # entities
+
+          MessageEntities.parse(data, offset).first
+        rescue StandardError
+          []
+        end
+
         # The low-level TL primitives, shared from Reader.
         def x
           Reader

data/lib/mtproto/tl/objects/messages_add_chat_user.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.addChatUser — add a user to a basic group chat. Returns
+    # messages.InvitedUsers.
+    class MessagesAddChatUser
+      include Binary
+
+      CONSTRUCTOR = 0xcbc6d107
+      INPUT_USER = 0xf21158c6
+
+      def initialize(chat_id:, user:, fwd_limit: 50)
+        @chat_id = chat_id
+        @user = user
+        @fwd_limit = fwd_limit
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) +
+          u64_b(@chat_id) +
+          u32_b(INPUT_USER) + u64_b(@user[:id]) + u64_b(@user[:access_hash] || 0) +
+          u32_b(@fwd_limit)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/messages_create_chat.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.createChat — create a basic group chat seeded with an initial set
+    # of users (a basic chat cannot be created empty). Returns
+    # messages.InvitedUsers wrapping the creation Updates.
+    class MessagesCreateChat
+      include Binary
+
+      CONSTRUCTOR = 0x92ceddd4
+      INPUT_USER = 0xf21158c6
+
+      def initialize(users:, title:)
+        @users = users
+        @title = title
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(0) # flags: no ttl_period
+        result += u32_b(Constructors::VECTOR) + u32_b(@users.length)
+        @users.each do |u|
+          result += u32_b(INPUT_USER) + u64_b(u[:id]) + u64_b(u[:access_hash] || 0)
+        end
+        result += serialize_tl_string(@title)
+        result
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.to_s.b.bytes
+        length = bytes.length
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        [0] * ((4 - (current_length % 4)) % 4)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/reply_keyboard_markup.rb

@@ -9,16 +9,23 @@ module MTProto
       KEYBOARD_BUTTON_ROW = 0x77608b83
 
       # buttons: a single row of button objects (each responds to #serialize)
-      def initialize(buttons:, resize: true, single_use: false)
+      def initialize(buttons:, resize: true, single_use: false,
+                     selective: false, persistent: false, placeholder: nil)
         @buttons = buttons
         @resize = resize
         @single_use = single_use
+        @selective = selective
+        @persistent = persistent
+        @placeholder = placeholder
       end
 
       def serialize
         flags = 0
         flags |= (1 << 0) if @resize
         flags |= (1 << 1) if @single_use
+        flags |= (1 << 2) if @selective
+        flags |= (1 << 3) if @placeholder
+        flags |= (1 << 4) if @persistent
 
         result = u32_b(CONSTRUCTOR)
         result += u32_b(flags)
@@ -28,8 +35,26 @@ module MTProto
         result += u32_b(Constructors::VECTOR)
         result += u32_b(@buttons.size)
         @buttons.each { |button| result += button.serialize }
+        result += serialize_tl_string(@placeholder) if @placeholder
         result
       end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.encode('UTF-8').bytes
+        length = bytes.length
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
     end
   end
 end

data/lib/mtproto/tl/objects/send_message.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require_relative '../message_entity'
 
 module MTProto
   module TL
@@ -8,36 +9,69 @@ module MTProto
       include Binary
 
       INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
+      INPUT_RICH_MESSAGE_MARKDOWN = 0x004b572c
 
-      def initialize(peer:, message:, random_id: nil, reply_to: nil, reply_markup: nil, silent: false)
+      def initialize(peer:, message: '', random_id: nil, reply_to: nil, reply_markup: nil, silent: false,
+                     entities: nil, rich_markdown: nil, quote_text: nil, quote_offset: nil)
         @peer = peer
         @message = message
         @random_id = random_id || SecureRandom.random_number(2**63)
         @reply_to = reply_to
         @reply_markup = reply_markup
         @silent = silent
+        @entities = entities
+        @rich_markdown = rich_markdown
+        @quote_text = quote_text
+        @quote_offset = quote_offset
       end
 
       def serialize
         flags = 0
         flags |= (1 << 0) if @reply_to
         flags |= (1 << 2) if @reply_markup
+        flags |= (1 << 3) if entities?
         flags |= (1 << 5) if @silent
+        flags |= (1 << 23) if @rich_markdown # rich_message
 
         result = u32_b(Constructors::MESSAGES_SEND_MESSAGE)
         result += u32_b(flags)
         result += serialize_input_peer
         result += serialize_reply_to if @reply_to
-        result += serialize_tl_string(@message)
+        # Server-side rich markdown carries the whole message; the text field goes
+        # empty and no entities are sent (matches Telegram Desktop's sendRichMessage).
+        result += serialize_tl_string(@rich_markdown ? '' : @message)
         result += u64_b(@random_id)
         result += @reply_markup.serialize if @reply_markup
+        result += MessageEntities.serialize(@entities) if entities?
+        result += serialize_rich_markdown if @rich_markdown
         result
       end
 
       private
 
+      def entities?
+        @entities && !@entities.empty? && !@rich_markdown
+      end
+
+      # inputRichMessageMarkdown#004b572c flags:# rtl:flags.0?true noautolink:flags.1?true
+      # markdown:string files:flags.2?Vector<InputRichFile>. Text-only: flags=0, no files.
+      def serialize_rich_markdown
+        u32_b(INPUT_RICH_MESSAGE_MARKDOWN) + u32_b(0) + serialize_tl_string(@rich_markdown)
+      end
+
+      # inputReplyToMessage#3bd4b7c2 flags:# reply_to_msg_id:int quote_text:flags.2?string
+      # quote_offset:flags.4?int. A quote replies to @reply_to while pinning the exact
+      # fragment (@quote_text at @quote_offset in that message); Telegram validates the
+      # text against the original at the offset.
       def serialize_reply_to
-        u32_b(INPUT_REPLY_TO_MESSAGE) + u32_b(0) + u32_b(@reply_to)
+        flags = 0
+        flags |= (1 << 2) if @quote_text
+        flags |= (1 << 4) unless @quote_offset.nil?
+
+        result = u32_b(INPUT_REPLY_TO_MESSAGE) + u32_b(flags) + u32_b(@reply_to)
+        result += serialize_tl_string(@quote_text) if @quote_text
+        result += u32_b(@quote_offset) unless @quote_offset.nil?
+        result
       end
 
       def serialize_input_peer

data/lib/mtproto/tl/objects/update.rb

@@ -23,6 +23,21 @@ module MTProto
         end
       end
 
+      # Whether a top-level pushed message (as delivered to Client#on_update with
+      # its outer constructor and body) carries an updateLoginToken — the signal
+      # that a QR login token was scanned and accepted. Arrives bare or, in
+      # practice, wrapped in updateShort.
+      def self.login_token?(constructor, body)
+        case constructor
+        when Constructors::UPDATE_LOGIN_TOKEN
+          true
+        when Constructors::UPDATE_SHORT
+          UpdateShort.deserialize(body).update.type == 'login_token'
+        else
+          false
+        end
+      end
+
       class << self
         private