mtproto 0.0.15 → 0.0.17

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

@@ -1,37 +1,113 @@
 # frozen_string_literal: true
 
+require_relative '../reader'
+
 module MTProto
   module TL
+    # The high-level chat-message TL structure `message#7600b9d3` (text/media/
+    # fwd_from/reply/sender/...). Owns the field walk for that one constructor; the
+    # low-level TL reads it needs (peer/string/bytes/media/document, plus the
+    # shared schema) live in Reader and are reused here.
+    #
+    # Reading is decoupled from alignment: `.deserialize` only READS the fields we
+    # surface and returns a Message (or nil for a non-`message` constructor — e.g.
+    # messageService/messageEmpty). Advancing past the whole object is the caller's
+    # job via `Schema#skip`, so any unmodelled tail never drops the message. This is
+    # the single parser for all three inbound paths (live `Updates` push,
+    # `updates.getDifference`, and `messages.getHistory`).
     class Message
-      attr_reader :auth_key_id, :msg_id, :body
+      MESSAGE = Constructors::MESSAGE
+      MESSAGE_FWD_HEADER = 0x4e4df4bb
 
-      def initialize(auth_key_id:, msg_id:, body:)
-        @auth_key_id = auth_key_id
-        @msg_id = msg_id
-        @body = body
-      end
+      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
+
+      attr_reader(*FIELDS)
+
+      # `text` is the message body; a get_history-friendly alias for `message`.
+      alias text message
 
-      def serialize
-        auth_key_id_bytes = [@auth_key_id].pack('Q<')
-        msg_id_bytes = [@msg_id].pack('Q<')
-        body_length = [@body.bytesize].pack('L<')
+      def initialize(attrs)
+        FIELDS.each { |f| instance_variable_set("@#{f}", attrs[f]) }
+      end
 
-        auth_key_id_bytes + msg_id_bytes + body_length + @body
+      # The legacy hash shape the Updates / UpdatesDifference consumers expect.
+      def to_h
+        FIELDS.each_with_object({}) { |f, h| h[f] = public_send(f) }
       end
 
-      def self.deserialize(data)
-        if data.bytesize < 20
-          raise(ArgumentError,
-            'Invalid MTProto message: expected at least 20 bytes, ' \
-            "got #{data.bytesize} bytes (hex: #{data.unpack1('H*')})")
+      class << self
+        def deserialize(data, offset, constructor)
+          return unless constructor == MESSAGE
+
+          offset += 4 # constructor
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          flags2 = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('l<')
+          offset += 4
+
+          from_type = from_id = nil
+          from_type, from_id, offset = x.parse_peer(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          _, offset = x.read_tl_string(data, offset) if flags2.anybits?(1 << 12) # from_rank (layer 227)
+          peer_type, peer_id, offset = x.parse_peer(data, offset)
+          offset = x.schema.skip(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
+          fwd_from_type = fwd_from_id = nil
+          if flags.anybits?(1 << 2) # fwd_from
+            fwd_from_type, fwd_from_id = parse_fwd_origin(data, offset)
+            offset = x.schema.skip(data, offset)
+          end
+          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
+          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
+          if flags.anybits?(1 << 3) # reply_to
+            reply_to_msg_id, is_reply = x.parse_reply_to(data, offset)
+            offset = x.schema.skip(data, offset)
+          end
+
+          date = data[offset, 4].unpack1('L<')
+          offset += 4
+          message_text, offset = x.read_tl_string(data, offset)
+          has_media = flags.anybits?(1 << 9)
+          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
+
+          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)
         end
 
-        auth_key_id = data[0, 8].unpack1('Q<')
-        msg_id = data[8, 8].unpack1('Q<')
-        body_length = data[16, 4].unpack1('L<')
-        body = data[20, body_length]
+        private
+
+        # The low-level TL primitives, shared from Reader.
+        def x
+          Reader
+        end
 
-        new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
+        # messageFwdHeader#4e4df4bb flags:# imported:flags.7?true from_id:flags.0?Peer
+        # ... — from_id is the forward origin (a peerChannel for a forwarded channel
+        # post). imported (flags.7) is a flag-only bool, so from_id sits right after
+        # the flags. => [type, id] or [nil, nil].
+        def parse_fwd_origin(data, offset)
+          return [nil, nil] unless data[offset, 4].unpack1('L<') == MESSAGE_FWD_HEADER
+
+          io = offset + 4
+          flags = data[io, 4].unpack1('L<')
+          io += 4
+          return [nil, nil] unless flags.anybits?(1 << 0) # from_id present
+
+          type, id, = x.parse_peer(data, io)
+          [type, id]
+        rescue StandardError
+          [nil, nil]
+        end
       end
     end
   end

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

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
 require_relative '../schema'
+require_relative 'message'
 
 module MTProto
   module TL
+    # A messages.messages / messagesSlice / channelMessages container (e.g. the
+    # messages.getHistory reply). Its messages are TL::Message instances.
     class Messages
-      Message = Struct.new(:id, :from_id, :date, :text, keyword_init: true)
-
-      MESSAGES_MESSAGES = 0x8c718e87
-      MESSAGES_SLICE = 0x762b263d
+      MESSAGES_MESSAGES = 0x1d73e7ea
+      MESSAGES_SLICE = 0x5f206716
       MESSAGES_CHANNEL = 0xc776ba4e
 
-      MESSAGE = Constructors::MESSAGE
-      MESSAGE_SERVICE = 0x7a800e0a
-      MESSAGE_EMPTY = 0x90a6ca84
-
       VALID_CONSTRUCTORS = [MESSAGES_MESSAGES, MESSAGES_SLICE, MESSAGES_CHANNEL].freeze
 
       attr_reader :messages, :count
@@ -86,76 +83,12 @@ module MTProto
           messages = []
           count.times do
             constructor = data[offset, 4].unpack1('L<')
-
-            if constructor == MESSAGE
-              msg, = parse_message(data, offset)
-              messages << msg if msg
-            end
-
+            msg = Message.deserialize(data, offset, constructor)
+            messages << msg if msg
             offset = schema.skip(data, offset)
           end
           [messages, offset]
         end
-
-        # message#9815cec8 flags:# flags2:# id:int
-        #   from_id:flags.8?Peer ... date:int message:string ...
-        def parse_message(data, offset)
-          offset += 4 # constructor
-          flags = data[offset, 4].unpack1('L<')
-          offset += 4
-          flags2 = data[offset, 4].unpack1('L<')
-          offset += 4
-          id = data[offset, 4].unpack1('l<')
-          offset += 4
-
-          from_id = nil
-          _, from_id, offset = parse_peer(data, offset) if flags.anybits?(1 << 8)
-          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
-          _, _, offset = parse_peer(data, offset) # peer_id (skip)
-          _, _, offset = parse_peer(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 2) # fwd_from
-          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
-          offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
-
-          date = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          text, offset = read_tl_string(data, offset)
-
-          msg = Message.new(id: id, from_id: from_id, date: date, text: text)
-          [msg, offset]
-        end
-
-        def parse_peer(data, offset)
-          constructor = data[offset, 4].unpack1('L<')
-          offset += 4
-          case constructor
-          when Constructors::PEER_USER
-            [:user, data[offset, 8].unpack1('Q<'), offset + 8]
-          when Constructors::PEER_CHAT
-            [:chat, data[offset, 8].unpack1('Q<'), offset + 8]
-          when Constructors::PEER_CHANNEL
-            [:channel, data[offset, 8].unpack1('Q<'), offset + 8]
-          else
-            raise "Unknown peer constructor: 0x#{constructor.to_s(16)}"
-          end
-        end
-
-        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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReplyInlineMarkup
+      include Binary
+
+      CONSTRUCTOR = 0x48a30254
+      KEYBOARD_BUTTON_ROW = 0x77608b83
+
+      # rows: array of rows; each row is an array of button objects (each responds to #serialize).
+      def initialize(rows:)
+        @rows = rows
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(@rows.size)
+        @rows.each do |row|
+          result += u32_b(KEYBOARD_BUTTON_ROW)
+          result += u32_b(Constructors::VECTOR)
+          result += u32_b(row.size)
+          row.each { |button| result += button.serialize }
+        end
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'bot_command_scope'
+
+module MTProto
+  module TL
+    # bots.resetBotCommands — clear the bot's commands for a given scope/language.
+    # Returns Bool.
+    class ResetBotCommands
+      include Binary
+
+      CONSTRUCTOR = 0x3d8de0f9
+
+      # scope: BotCommandScope hash (see BotCommandScope); defaults to default scope.
+      def initialize(scope: { type: :default }, lang_code: '')
+        @scope = scope
+        @lang_code = lang_code
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += BotCommandScope.serialize(@scope)
+        result += serialize_tl_string(@lang_code)
+        result
+      end
+
+      private
+
+      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/send_media.rb

@@ -7,19 +7,25 @@ module MTProto
     class SendMedia
       include Binary
 
-      INPUT_REPLY_TO_MESSAGE = 0x869fbe10
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
+      INPUT_MEDIA_PHOTO = 0xe3af4434
+      INPUT_MEDIA_DOCUMENT = 0xa8763ab5
+      INPUT_PHOTO = 0x3bb3b94a
+      INPUT_DOCUMENT = 0x1abfb575
 
-      def initialize(peer:, media:, message: '', random_id: nil, reply_to: nil)
+      def initialize(peer:, media:, message: '', random_id: nil, reply_to: nil, silent: false)
         @peer = peer
         @media = media
         @message = message
         @random_id = random_id || SecureRandom.random_number(2**63)
         @reply_to = reply_to
+        @silent = silent
       end
 
       def serialize
         flags = 0
         flags |= (1 << 0) if @reply_to
+        flags |= (1 << 5) if @silent
 
         result = u32_b(Constructors::MESSAGES_SEND_MEDIA)
         result += u32_b(flags)
@@ -56,11 +62,27 @@ module MTProto
         case @media[:type]
         when :uploaded_photo
           serialize_input_media_uploaded_photo(@media[:file])
+        when :uploaded_document
+          serialize_input_media_uploaded_document(@media)
+        when :photo
+          serialize_existing_media(INPUT_MEDIA_PHOTO, INPUT_PHOTO, @media)
+        when :document
+          serialize_existing_media(INPUT_MEDIA_DOCUMENT, INPUT_DOCUMENT, @media)
         else
           raise "Unknown media type: #{@media[:type]}"
         end
       end
 
+      # Re-send media that already lives on Telegram, by reference — inputMediaPhoto/
+      # inputMediaDocument (flags=0) wrapping inputPhoto/inputDocument(id, access_hash,
+      # file_reference). Used to re-post a guest-mention's photo/video, where the bot
+      # cannot forward from a chat it is not a member of.
+      def serialize_existing_media(media_ctor, input_ctor, media)
+        u32_b(media_ctor) + u32_b(0) +
+          u32_b(input_ctor) + u64_b(media[:id]) + u64_b(media[:access_hash]) +
+          serialize_bytes(media[:file_reference])
+      end
+
       def serialize_input_media_uploaded_photo(file)
         result = u32_b(Constructors::INPUT_MEDIA_UPLOADED_PHOTO)
         result += u32_b(0) # flags
@@ -68,6 +90,48 @@ module MTProto
         result
       end
 
+      # inputMediaUploadedDocument with flags=0 (no thumb/stickers/ttl/video
+      # fields): file, mime_type, then the document-attributes vector. A generic
+      # file carries documentAttributeFilename; audio adds documentAttributeAudio.
+      def serialize_input_media_uploaded_document(media)
+        u32_b(Constructors::INPUT_MEDIA_UPLOADED_DOCUMENT) +
+          u32_b(0) +
+          serialize_input_file(media[:file]) +
+          serialize_tl_string(media[:mime_type].to_s) +
+          serialize_document_attributes(media[:attributes] || [])
+      end
+
+      def serialize_document_attributes(attributes)
+        result = u32_b(Constructors::VECTOR) + u32_b(attributes.length)
+        attributes.each { |attribute| result += serialize_document_attribute(attribute) }
+        result
+      end
+
+      def serialize_document_attribute(attribute)
+        case attribute[:type]
+        when :filename
+          u32_b(Constructors::DOCUMENT_ATTRIBUTE_FILENAME) +
+            serialize_tl_string(attribute[:file_name].to_s)
+        when :audio
+          serialize_document_attribute_audio(attribute)
+        else
+          raise "Unknown document attribute: #{attribute[:type]}"
+        end
+      end
+
+      # documentAttributeAudio: voice=flags.10, title=flags.0, performer=flags.1;
+      # title is written before performer on the wire.
+      def serialize_document_attribute_audio(attribute)
+        flags = 0
+        flags |= (1 << 0) if attribute[:title]
+        flags |= (1 << 1) if attribute[:performer]
+        flags |= (1 << 10) if attribute[:voice]
+        result = u32_b(Constructors::DOCUMENT_ATTRIBUTE_AUDIO) + u32_b(flags) + u32_b(attribute[:duration].to_i)
+        result += serialize_tl_string(attribute[:title]) if attribute[:title]
+        result += serialize_tl_string(attribute[:performer]) if attribute[:performer]
+        result
+      end
+
       def serialize_input_file(file)
         u32_b(Constructors::INPUT_FILE) +
           u64_b(file[:id]) +
@@ -77,9 +141,17 @@ module MTProto
       end
 
       def serialize_tl_string(str)
-        bytes = str.encode('UTF-8').bytes
-        length = bytes.length
+        serialize_byte_array(str.encode('UTF-8').bytes)
+      end
 
+      # TL bytes for a raw binary string (e.g. a file_reference) — NOT re-encoded as
+      # UTF-8, which would corrupt arbitrary bytes.
+      def serialize_bytes(raw)
+        serialize_byte_array(raw.to_s.b.bytes)
+      end
+
+      def serialize_byte_array(bytes)
+        length = bytes.length
         if length <= 253
           [length] + bytes + padding(length + 1)
         else

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

@@ -7,20 +7,22 @@ module MTProto
     class SendMessage
       include Binary
 
-      INPUT_REPLY_TO_MESSAGE = 0x869fbe10
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
 
-      def initialize(peer:, message:, random_id: nil, reply_to: nil, reply_markup: nil)
+      def initialize(peer:, message:, random_id: nil, reply_to: nil, reply_markup: nil, silent: false)
         @peer = peer
         @message = message
         @random_id = random_id || SecureRandom.random_number(2**63)
         @reply_to = reply_to
         @reply_markup = reply_markup
+        @silent = silent
       end
 
       def serialize
         flags = 0
         flags |= (1 << 0) if @reply_to
         flags |= (1 << 2) if @reply_markup
+        flags |= (1 << 5) if @silent
 
         result = u32_b(Constructors::MESSAGES_SEND_MESSAGE)
         result += u32_b(flags)

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # A SendMessageAction — the payload of messages.setTyping. Every variant is
+    # just its own constructor id; the upload/import variants additionally carry
+    # a progress:int (0-100). One class covers them all.
+    class SendMessageAction
+      include Binary
+
+      CONSTRUCTORS = {
+        typing: 0x16bf744e,
+        cancel: 0xfd5ec8f5,
+        record_audio: 0xd52f73f7,
+        upload_audio: 0xf351d7ab,
+        record_video: 0xa187d66f,
+        upload_video: 0xe9763aec,
+        record_round: 0x88f27fbc,
+        upload_round: 0x243e1c66,
+        upload_photo: 0xd1d34a26,
+        upload_document: 0xaa0cd9e4,
+        geo_location: 0x176f8ba1,
+        choose_contact: 0x628cbc6f,
+        choose_sticker: 0xb05ac6b1,
+        game_play: 0xdd6a8f48,
+        history_import: 0xdbda9246
+      }.freeze
+
+      WITH_PROGRESS = %i[upload_audio upload_video upload_round upload_photo upload_document history_import].freeze
+
+      def self.types
+        CONSTRUCTORS.keys
+      end
+
+      def initialize(type, progress: 0)
+        @type = type
+        @progress = progress
+      end
+
+      def serialize
+        id = CONSTRUCTORS.fetch(@type) { raise ArgumentError, "unknown SendMessageAction: #{@type}" }
+        result = u32_b(id)
+        result += u32_b(@progress) if WITH_PROGRESS.include?(@type)
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.setBotCallbackAnswer — the bot's reaction to a press. With no
+    # message it just dismisses the button's spinner; with a message it shows a
+    # toast (alert=false) or a modal alert (alert=true).
+    class SetBotCallbackAnswer
+      include Binary
+
+      CONSTRUCTOR = 0xd58f130a
+
+      def initialize(query_id:, message: nil, alert: false, url: nil, cache_time: 0)
+        @query_id = query_id
+        @message = message
+        @alert = alert
+        @url = url
+        @cache_time = cache_time
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @message
+        flags |= (1 << 1) if @alert
+        flags |= (1 << 2) if @url
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += u64_b(@query_id)
+        result += serialize_tl_string(@message) if @message
+        result += serialize_tl_string(@url) if @url
+        result += u32_b(@cache_time)
+        result
+      end
+
+      private
+
+      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/set_bot_commands.rb

@@ -1,23 +1,26 @@
 # frozen_string_literal: true
 
+require_relative 'bot_command_scope'
+
 module MTProto
   module TL
     class SetBotCommands
       include Binary
 
       CONSTRUCTOR = 0x0517165a
-      BOT_COMMAND_SCOPE_DEFAULT = 0x2f6cb2ab
       BOT_COMMAND = 0xc27ac8c7
 
       # commands: array of { command:, description: }
-      def initialize(commands:, lang_code: '')
+      # scope:    BotCommandScope hash (see BotCommandScope); defaults to default scope.
+      def initialize(commands:, scope: { type: :default }, lang_code: '')
         @commands = commands
+        @scope = scope
         @lang_code = lang_code
       end
 
       def serialize
         result = u32_b(CONSTRUCTOR)
-        result += u32_b(BOT_COMMAND_SCOPE_DEFAULT)
+        result += BotCommandScope.serialize(@scope)
         result += serialize_tl_string(@lang_code)
         result += u32_b(Constructors::VECTOR)
         result += u32_b(@commands.size)

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    # messages.setBotGuestChatResult#b8f106e3 query_id:long result:InputBotInlineResult
+    #   = InputBotInlineMessageID
+    # How a guest-mode bot answers an updateBotGuestChatQuery: the reply text is wrapped
+    # in inputBotInlineResult(type "article") -> inputBotInlineMessageText, and the server
+    # posts that message into the guest chat. Text-only for now (no media / buttons).
+    class SetBotGuestChatResult
+      include Binary
+
+      CONSTRUCTOR = 0xb8f106e3
+      INPUT_BOT_INLINE_RESULT = 0x88bf9319         # inputBotInlineResult
+      INPUT_BOT_INLINE_MESSAGE_TEXT = 0x3dcd7a87   # inputBotInlineMessageText
+
+      def initialize(query_id:, message:, result_id: nil, result_type: 'article', result_title: nil)
+        @query_id = query_id
+        @message = message
+        @result_id = result_id || SecureRandom.hex(8)
+        @result_type = result_type
+        # The "article" result type requires a non-empty title (the server rejects an
+        # empty one with ARTICLE_TITLE_EMPTY); the actual reply shown is send_message.
+        @result_title = result_title || message_title
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u64_b(@query_id)
+        result += serialize_result
+        result
+      end
+
+      private
+
+      # inputBotInlineResult#88bf9319 flags:# id:string type:string
+      #   title:flags.1?string description:flags.2? ... send_message:InputBotInlineMessage
+      # flags = 1<<1: id/type + the required title, then send_message.
+      def serialize_result
+        result = u32_b(INPUT_BOT_INLINE_RESULT)
+        result += u32_b(1 << 1) # title present
+        result += serialize_tl_string(@result_id)
+        result += serialize_tl_string(@result_type)
+        result += serialize_tl_string(@result_title)
+        result += serialize_send_message
+        result
+      end
+
+      def message_title
+        title = @message.to_s.strip
+        title = 'Ответ' if title.empty?
+        title[0, 64]
+      end
+
+      # inputBotInlineMessageText#3dcd7a87 flags:# no_webpage:flags.0?true
+      #   invert_media:flags.3?true message:string entities:flags.1? reply_markup:flags.2?
+      # flags = 0: a plain text message.
+      def serialize_send_message
+        result = u32_b(INPUT_BOT_INLINE_MESSAGE_TEXT)
+        result += u32_b(0)
+        result += serialize_tl_string(@message)
+        result
+      end
+
+      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