mtproto 0.0.15 → 0.0.19

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

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.setTyping — show a chat action ("typing…", "sending photo…", …)
+    # in the target peer. action is a SendMessageAction; top_msg_id targets a
+    # forum topic / thread. Returns Bool.
+    class SetTyping
+      include Binary
+
+      CONSTRUCTOR = 0x58943ee2
+
+      def initialize(peer:, action:, top_msg_id: nil)
+        @peer = peer
+        @action = action
+        @top_msg_id = top_msg_id
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @top_msg_id
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += u32_b(@top_msg_id) if @top_msg_id
+        result += @action.serialize
+        result
+      end
+
+      private
+
+      def serialize_input_peer
+        case @peer[:type]
+        when :self
+          u32_b(Constructors::INPUT_PEER_SELF)
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(@peer[:id]) + u64_b(@peer[:access_hash] || 0)
+        when :chat
+          u32_b(Constructors::INPUT_PEER_CHAT) + u64_b(@peer[:id])
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(@peer[:id]) + u64_b(@peer[:access_hash] || 0)
+        else
+          raise "Unknown peer type: #{@peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # account.updateStatus — mark the session online or offline. offline:false
+    # is what a foreground client sends to go online (and to start receiving
+    # transient updates like updateUserTyping). Returns Bool.
+    class UpdateStatus
+      include Binary
+
+      CONSTRUCTOR = 0x6628562c
+      BOOL_TRUE = 0x997275b5
+      BOOL_FALSE = 0xbc799737
+
+      def initialize(offline:)
+        @offline = offline
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) + u32_b(@offline ? BOOL_TRUE : BOOL_FALSE)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative '../reader'
+require_relative 'message'
+require_relative 'dialogs'
+
+module MTProto
+  module TL
+    # The live `updates`#74ae4240 / `updatesCombined`#725b04c3 push container a bot
+    # receives in real time (as opposed to the `updates.getDifference` reply
+    # UpdatesDifference handles). Mines the message-bearing updates into structured
+    # messages — including any media — and returns the senders in users[] for the
+    # peer/access_hash cache. Each update is advanced via Schema#skip, so an update
+    # type we don't model never drops the ones we do.
+    class Updates
+      attr_reader :messages, :users, :chats, :callback_queries, :guest_queries
+
+      UPDATE_NEW_MESSAGE = 0x1f2b0afd
+      UPDATE_NEW_CHANNEL_MESSAGE = 0x62ba04d9
+      UPDATE_BOT_CALLBACK_QUERY = 0xb9cfc48d
+      UPDATE_BOT_GUEST_CHAT_QUERY = 0xcdd4093d
+
+      def initialize(messages:, users:, chats:, callback_queries: [], guest_queries: [])
+        @messages = messages
+        @users = users
+        @chats = chats
+        @callback_queries = callback_queries
+        @guest_queries = guest_queries
+      end
+
+      # updates: updates:Vector<Update> users:Vector<User> chats:Vector<Chat> ...
+      # (updatesCombined adds a seq_start before seq; both share this prefix).
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        unless [Constructors::UPDATES, Constructors::UPDATES_COMBINED].include?(constructor)
+          return new(messages: [], users: [], chats: [], callback_queries: [], guest_queries: [])
+        end
+
+        messages, callback_queries, guest_queries, offset = parse_updates_vector(data, 4)
+        users, offset = Dialogs.users_at(data, offset)
+        chats, = Dialogs.chats_at(data, offset)
+        new(messages: messages, users: users, chats: chats,
+          callback_queries: callback_queries, guest_queries: guest_queries)
+      end
+
+      def self.parse_updates_vector(data, offset)
+        offset += 4 # vector constructor
+        count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        messages = []
+        callback_queries = []
+        guest_queries = []
+        count.times do
+          ctor = data[offset, 4].unpack1('L<')
+          if [UPDATE_NEW_MESSAGE, UPDATE_NEW_CHANNEL_MESSAGE].include?(ctor)
+            inner = offset + 4
+            msg = Message.deserialize(data, inner, data[inner, 4].unpack1('L<'))
+            messages << msg.to_h if msg
+          elsif ctor == UPDATE_BOT_CALLBACK_QUERY
+            callback_queries << extract_callback_query(data, offset)
+          elsif ctor == UPDATE_BOT_GUEST_CHAT_QUERY
+            guest_queries << extract_guest_query(data, offset)
+          end
+          offset = Reader.schema.skip(data, offset)
+        end
+        [messages, callback_queries, guest_queries, offset]
+      end
+
+      # updateBotCallbackQuery#b9cfc48d flags:# query_id:long user_id:long peer:Peer
+      #   msg_id:int chat_instance:long data:flags.0?bytes game_short_name:flags.1?string
+      # A bot receives this when a user taps an inline callback button; the data is
+      # the button's callback payload. The outer loop advances past it via Schema#skip.
+      def self.extract_callback_query(data, offset)
+        offset += 4 # constructor
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        query_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        user_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        peer_type, peer_id, offset = Reader.parse_peer(data, offset)
+        msg_id = data[offset, 4].unpack1('l<')
+        offset += 4
+        offset += 8 # chat_instance (unused)
+        payload = nil
+        payload, = Reader.read_tl_bytes(data, offset) if flags.anybits?(1 << 0)
+
+        { query_id: query_id, user_id: user_id, peer_type: peer_type, peer_id: peer_id,
+          msg_id: msg_id, data: payload }
+      end
+
+      # updateBotGuestChatQuery#cdd4093d flags:# query_id:long message:Message
+      #   reference_messages:flags.0?Vector<Message> qts:int
+      # A guest-mode bot receives this when a user @-mentions it in a chat it is NOT a
+      # member of; the inner message is the mentioning message (sender in from_id). The
+      # bot answers once with messages.setBotGuestChatResult(query_id, result). The outer
+      # loop advances past the whole update via Schema#skip, so this only needs to read
+      # the fields we surface (query_id + the parsed message + qts).
+      def self.extract_guest_query(data, offset)
+        offset += 4 # constructor
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        query_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        msg = Message.deserialize(data, offset, data[offset, 4].unpack1('L<'))
+        offset = Reader.schema.skip(data, offset) # message:Message
+        if flags.anybits?(1 << 0) # reference_messages:Vector<Message>
+          offset = Reader.schema.skip_vector(data, offset) { |d, o| Reader.schema.skip(d, o) }
+        end
+        qts = data[offset, 4].unpack1('l<')
+
+        { query_id: query_id, message: msg&.to_h, qts: qts }
+      end
+    end
+  end
+end

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

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require_relative '../schema'
+require_relative 'message'
 require_relative 'dialogs'
+require_relative 'updates'
 
 module MTProto
   module TL
     class UpdatesDifference
-      attr_reader :type, :date, :seq, :new_messages, :pts, :state, :chats, :users
+      attr_reader :type, :date, :seq, :new_messages, :pts, :state, :chats, :users, :guest_queries
 
       SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
 
-      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil, chats: [], users: [])
+      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil, chats: [], users: [],
+                     guest_queries: [])
         @type = type
         @date = date
         @seq = seq
@@ -19,6 +22,7 @@ module MTProto
         @state = state
         @chats = chats
         @users = users
+        @guest_queries = guest_queries
       end
 
       def self.schema
@@ -41,12 +45,6 @@ module MTProto
         end
       end
 
-      MESSAGE_CONSTRUCTOR = Constructors::MESSAGE
-      MESSAGE_SERVICE = 0x7a800e0a
-      MESSAGE_EMPTY = 0x90a6ca84
-      MESSAGE_REPLY_HEADER = 0x6917560b
-      MEDIA_PHOTO = 0x695150d7
-      MEDIA_DOCUMENT = 0x52d8ccd9
       UPDATE_NEW_MESSAGE = 0x1f2b0afd
       UPDATE_NEW_CHANNEL_MESSAGE = 0x62ba04d9
 
@@ -70,7 +68,7 @@ module MTProto
 
           messages, offset = parse_messages_vector(data, offset)
           offset = schema.skip_vector(data, offset) # new_encrypted_messages
-          other_messages, offset = parse_other_updates(data, offset)
+          other_messages, guest_queries, offset = parse_other_updates(data, offset)
           chats, offset = Dialogs.chats_at(data, offset)
           users, offset = Dialogs.users_at(data, offset)
           state = UpdatesState.deserialize(data[offset..])
@@ -78,6 +76,7 @@ module MTProto
           new(
             type: constructor == Constructors::UPDATES_DIFFERENCE ? :difference : :slice,
             new_messages: messages + other_messages,
+            guest_queries: guest_queries,
             chats: chats, users: users, state: state
           )
         end
@@ -91,16 +90,19 @@ module MTProto
           offset += 4
 
           messages = []
+          guest_queries = []
           count.times do
             ctor = data[offset, 4].unpack1('L<')
             if [UPDATE_NEW_MESSAGE, UPDATE_NEW_CHANNEL_MESSAGE].include?(ctor)
               inner_off = offset + 4
-              msg = extract_message(data, inner_off, data[inner_off, 4].unpack1('L<'))
-              messages << msg if msg
+              msg = Message.deserialize(data, inner_off, data[inner_off, 4].unpack1('L<'))
+              messages << msg.to_h if msg
+            elsif ctor == Updates::UPDATE_BOT_GUEST_CHAT_QUERY
+              guest_queries << Updates.extract_guest_query(data, offset)
             end
             offset = schema.skip(data, offset)
           end
-          [messages, offset]
+          [messages, guest_queries, offset]
         end
 
         def parse_messages_vector(data, offset)
@@ -111,117 +113,12 @@ module MTProto
           messages = []
           count.times do
             constructor = data[offset, 4].unpack1('L<')
-            msg = extract_message(data, offset, constructor)
-            messages << msg if msg
+            msg = Message.deserialize(data, offset, constructor)
+            messages << msg.to_h if msg
             offset = schema.skip(data, offset)
           end
           [messages, offset]
         end
-
-        def extract_message(data, offset, constructor)
-          return unless constructor == MESSAGE_CONSTRUCTOR
-
-          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 = parse_peer(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
-          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
-          peer_type, peer_id, offset = parse_peer(data, offset)
-          offset = schema.skip(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
-
-          is_reply = false
-          reply_to_msg_id = nil
-          if flags.anybits?(1 << 3) # reply_to
-            reply_to_msg_id, is_reply = parse_reply_to(data, offset)
-            offset = schema.skip(data, offset)
-          end
-
-          date = data[offset, 4].unpack1('L<')
-          offset += 4
-          message_text, offset = read_tl_string(data, offset)
-          media = flags.anybits?(1 << 9) ? parse_media(data, offset) : nil
-
-          { 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, is_reply: is_reply, reply_to_msg_id: reply_to_msg_id }
-        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
-
-        # messageReplyHeader: ctor, flags, reply_to_msg_id:flags.4?int (first payload
-        # field). A plain message in a forum topic carries this header (forum_topic
-        # flags.3) but is a reply only when it targets a message in the topic
-        # (reply_to_top_id flags.1). => [reply_to_msg_id, is_reply]
-        def parse_reply_to(data, offset)
-          return [nil, false] unless data[offset, 4].unpack1('L<') == MESSAGE_REPLY_HEADER
-
-          io = offset + 4
-          flags = data[io, 4].unpack1('L<')
-          io += 4
-          forum_topic = flags.anybits?(1 << 3)
-          msg_id = flags.anybits?(1 << 4) ? data[io, 4].unpack1('l<') : nil
-          [msg_id, forum_topic ? flags.anybits?(1 << 1) : true]
-        rescue StandardError
-          [nil, false]
-        end
-
-        # Classify message media into :photo / :video / :audio / :document, or nil.
-        def parse_media(data, offset)
-          case data[offset, 4].unpack1('L<')
-          when MEDIA_PHOTO
-            :photo
-          when MEDIA_DOCUMENT
-            document_kind(data[offset + 4, 4].unpack1('L<'))
-          end
-        rescue StandardError
-          nil
-        end
-
-        # messageMediaDocument flags: video flags.6 / round flags.7 / voice flags.8.
-        def document_kind(flags)
-          return :video if flags.anybits?(1 << 6) || flags.anybits?(1 << 7)
-          return :audio if flags.anybits?(1 << 8)
-
-          :document
-        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/reader.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+
+module MTProto
+  module TL
+    # Shared read-only TL primitives — peer/string/bytes/media/document reads and
+    # the schema handle — reused by the message parser (TL::Message) and the other
+    # update parsers. Each method only READS; advancing past a whole object is the
+    # caller's job via `Schema#skip`, so any unmodelled tail is sized by the schema.
+    module Reader
+      module_function
+
+      SCHEMA_PATH = File.expand_path('../../../data/tl-schema.json', __dir__)
+
+      MESSAGE_REPLY_HEADER = 0x1b97dd66
+      MEDIA_PHOTO = 0xe216eb63
+      MEDIA_DOCUMENT = 0x52d8ccd9
+      DOCUMENT = 0x8fd4c4d8
+      PHOTO = 0xfb197a65
+      DOCUMENT_ATTRIBUTE_AUDIO = 0x9852f9c6
+      DOCUMENT_ATTRIBUTE_FILENAME = 0x15590068
+
+      def schema
+        @schema ||= Schema.new(SCHEMA_PATH)
+      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
+
+      # messageReplyHeader: ctor, flags, reply_to_msg_id:flags.4?int (first payload
+      # field). A plain message in a forum topic carries this header (forum_topic
+      # flags.3) but is a reply only when it targets a message in the topic
+      # (reply_to_top_id flags.1). => [reply_to_msg_id, is_reply]
+      def parse_reply_to(data, offset)
+        return [nil, false] unless data[offset, 4].unpack1('L<') == MESSAGE_REPLY_HEADER
+
+        io = offset + 4
+        flags = data[io, 4].unpack1('L<')
+        io += 4
+        forum_topic = flags.anybits?(1 << 3)
+        msg_id = flags.anybits?(1 << 4) ? data[io, 4].unpack1('l<') : nil
+        [msg_id, forum_topic ? flags.anybits?(1 << 1) : true]
+      rescue StandardError
+        [nil, false]
+      end
+
+      # Classify message media into :photo / :video / :audio / :document, or nil.
+      def parse_media(data, offset)
+        case data[offset, 4].unpack1('L<')
+        when MEDIA_PHOTO
+          :photo
+        when MEDIA_DOCUMENT
+          document_kind(data[offset + 4, 4].unpack1('L<'))
+        end
+      rescue StandardError
+        nil
+      end
+
+      # messageMediaDocument flags: video flags.6 / round flags.7 / voice flags.8.
+      def document_kind(flags)
+        return :video if flags.anybits?(1 << 6) || flags.anybits?(1 << 7)
+        return :audio if flags.anybits?(1 << 8)
+
+        :document
+      end
+
+      # When the media is messageMediaDocument, pull the document's downloadable
+      # fields (file location + audio metadata); nil for any other media. The
+      # thumb vectors before dc_id are sized by the schema, so this reaches dc_id
+      # and the attribute list correctly regardless of thumbnails.
+      def parse_document(data, offset)
+        return unless data[offset, 4].unpack1('L<') == MEDIA_DOCUMENT
+
+        media_flags = data[offset + 4, 4].unpack1('L<')
+        return unless media_flags.anybits?(1 << 0) # document present
+
+        offset += 8
+        return unless data[offset, 4].unpack1('L<') == DOCUMENT
+
+        offset += 4
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        id = data[offset, 8].unpack1('q<')
+        access_hash = data[offset + 8, 8].unpack1('q<')
+        offset += 16
+        file_reference, offset = read_tl_bytes(data, offset)
+        offset += 4 # date
+        mime_type, offset = read_tl_string(data, offset)
+        size = data[offset, 8].unpack1('q<')
+        offset += 8
+        offset = schema.skip_vector(data, offset) if flags.anybits?(1 << 0) # thumbs
+        offset = schema.skip_vector(data, offset) if flags.anybits?(1 << 1) # video_thumbs
+        dc_id = data[offset, 4].unpack1('l<')
+        offset += 4
+        voice, duration, file_name = parse_document_attributes(data, offset)
+
+        { id: id, access_hash: access_hash, file_reference: file_reference, dc_id: dc_id,
+          mime_type: mime_type, size: size, voice: voice, duration: duration, file_name: file_name }
+      rescue StandardError
+        nil
+      end
+
+      # When the media is messageMediaPhoto, pull the photo's input reference
+      # (id/access_hash/file_reference) so it can be re-sent via inputMediaPhoto —
+      # e.g. re-posting a guest-mention's photo, where forwarding is not allowed.
+      # has_stickers is a true-flag (no body), so id starts right after photo's flags.
+      def parse_photo(data, offset)
+        return unless data[offset, 4].unpack1('L<') == MEDIA_PHOTO
+
+        media_flags = data[offset + 4, 4].unpack1('L<')
+        return unless media_flags.anybits?(1 << 0) # photo present
+
+        offset += 8 # messageMediaPhoto ctor + flags
+        return unless data[offset, 4].unpack1('L<') == PHOTO
+
+        offset += 8 # photo ctor + flags
+        id = data[offset, 8].unpack1('q<')
+        access_hash = data[offset + 8, 8].unpack1('q<')
+        offset += 16
+        file_reference, = read_tl_bytes(data, offset)
+
+        { id: id, access_hash: access_hash, file_reference: file_reference }
+      rescue StandardError
+        nil
+      end
+
+      # Vector<DocumentAttribute>: pull voice/duration from documentAttributeAudio
+      # and the name from documentAttributeFilename; advance over the rest via
+      # schema so an unknown attribute never throws off the read.
+      def parse_document_attributes(data, offset)
+        offset += 4 # vector constructor
+        count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        voice = false
+        duration = nil
+        file_name = nil
+        count.times do
+          ctor = data[offset, 4].unpack1('L<')
+          case ctor
+          when DOCUMENT_ATTRIBUTE_AUDIO
+            aflags = data[offset + 4, 4].unpack1('L<')
+            voice ||= aflags.anybits?(1 << 10)
+            duration = data[offset + 8, 4].unpack1('l<')
+          when DOCUMENT_ATTRIBUTE_FILENAME
+            file_name, = read_tl_string(data, offset + 4)
+          end
+          offset = schema.skip(data, offset)
+        end
+        [voice, duration, file_name]
+      end
+
+      def read_tl_string(data, offset)
+        bytes, offset = read_tl_bytes(data, offset)
+        [bytes.force_encoding('UTF-8'), offset]
+      end
+
+      def read_tl_bytes(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], offset + total + padding]
+      end
+    end
+  end
+end

data/lib/mtproto/transport/abridged_packet_codec.rb

@@ -22,7 +22,11 @@ module MTProto
         @stream.write packet.data.pack('C*')
       end
 
-      MAX_PACKET_SIZE = 1_048_576
+      # The largest packet the abridged length field can express: a 3-byte
+      # little-endian count of 4-byte words, i.e. ((1 << 24) - 1) words << 2.
+      # The old 1 MiB cap couldn't receive a full 1 MiB getFile reply (~1 MiB +
+      # envelope ≈ 1048680 B), so files larger than 1 MiB never downloaded.
+      MAX_PACKET_SIZE = ((1 << 24) - 1) << 2
 
       def scan
         first_byte = read_exactly(1)