mtproto 0.0.32 → 0.0.34

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReplyKeyboardForceReply
+      include Binary
+
+      CONSTRUCTOR = 0x86b40b08
+
+      def initialize(single_use: false, selective: false, placeholder: nil)
+        @single_use = single_use
+        @selective = selective
+        @placeholder = placeholder
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 1) if @single_use
+        flags |= (1 << 2) if @selective
+        flags |= (1 << 3) if @placeholder
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        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/resolved_peer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../reader'
+require_relative '../peers'
+
+module MTProto
+  module TL
+    class ResolvedPeer
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::CONTACTS_RESOLVED_PEER
+
+        type, id, offset = Reader.parse_peer(data, 4)
+        chats, offset = Peers.chats_at(data, offset)
+        users, = Peers.users_at(data, offset)
+
+        { type: type, id: id, access_hash: access_hash_for(type, id, chats, users) }
+      end
+
+      def self.access_hash_for(type, id, chats, users)
+        return chats.find { |chat| chat.id == id }&.access_hash unless type == :user
+
+        user = users.find { |candidate| candidate[:id] == id }
+        user && user[:access_hash]
+      end
+      private_class_method :access_hash_for
+    end
+  end
+end

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

@@ -52,7 +52,7 @@ module MTProto
       private
 
       def entities?
-        @entities && !@entities.empty? && !@rich_markdown
+        !@entities.nil? && !@rich_markdown
       end
 
       # inputRichMessageMarkdown#004b572c flags:# rtl:flags.0?true noautolink:flags.1?true

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../message_entity'
+
+module MTProto
+  module TL
+    # A SendMessageAction carrying a live draft: the partially generated answer the
+    # recipient's client shows at the bottom of the chat while it is still being
+    # written. Unlike the other actions it is not a bare constructor id, so it does
+    # not fit TL::SendMessageAction's id-plus-progress table.
+    #
+    # `random_id` identifies the draft: the same value updates the draft already on
+    # screen, a different one puts a second draft beside it.
+    class SendMessageTextDraftAction
+      include Binary
+
+      CONSTRUCTOR = 0x376d975c
+      TEXT_WITH_ENTITIES = 0x751f3146
+
+      def initialize(random_id:, text:, entities: [])
+        @random_id = random_id
+        @text = text
+        @entities = entities
+      end
+
+      # textWithEntities#751f3146 text:string entities:Vector<MessageEntity> — the
+      # entity vector is not optional, so an empty list still goes on the wire.
+      def serialize
+        u32_b(CONSTRUCTOR) + u64_b(@random_id) +
+          u32_b(TEXT_WITH_ENTITIES) + serialize_tl_string(@text) +
+          MessageEntities.serialize(@entities)
+      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_multi_media.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'media_parts'
+
+module MTProto
+  module TL
+    # messages.sendMultiMedia — several photos as ONE message, the way a person sends an
+    # album.
+    #
+    # The words ride on the first of them and nowhere else: an album carries a single
+    # caption, and repeating it under each picture is how it looks when somebody sends
+    # them one at a time.
+    class SendMultiMedia
+      include MediaParts
+
+      CONSTRUCTOR = 0x1bf89d74
+      INPUT_SINGLE_MEDIA = 0x1cc6e91f
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
+
+      def initialize(peer:, photos:, message: '', reply_to: nil, silent: false)
+        @peer = peer
+        @photos = photos
+        @message = message
+        @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(CONSTRUCTOR) + u32_b(flags) + serialize_peer(@peer)
+        result += u32_b(INPUT_REPLY_TO_MESSAGE) + u32_b(0) + u32_b(@reply_to) if @reply_to
+        result += u32_b(Constructors::VECTOR) + u32_b(@photos.length)
+        @photos.each_with_index { |photo, nth| result += serialize_single(photo, nth) }
+        result
+      end
+
+      private
+
+      def serialize_single(photo, nth)
+        u32_b(INPUT_SINGLE_MEDIA) + u32_b(0) +
+          serialize_held_photo(photo) +
+          u64_b(SecureRandom.random_number(2**63)) +
+          serialize_text(nth.zero? ? @message.to_s : '')
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'message'
+
 module MTProto
   module TL
     class Update
@@ -50,41 +52,7 @@ module MTProto
         end
 
         def extract_new_message_text(bytes)
-          offset = 4 # skip updateNewMessage constructor
-
-          msg_constructor = bytes[offset, 4].unpack1('L<')
-          return nil unless msg_constructor == Constructors::MESSAGE
-
-          offset += 4
-          flags = bytes[offset, 4].unpack1('L<')
-          offset += 4
-          flags2 = bytes[offset, 4].unpack1('L<')
-          offset += 4
-          offset += 4 # id
-
-          offset += 12 if flags & (1 << 8) != 0 # from_id: Peer
-          offset += 12 # peer_id: Peer
-          offset += 12 if flags & (1 << 28) != 0 # saved_peer_id: Peer
-          return nil if flags & (1 << 2) != 0 # fwd_from: variable length
-
-          offset += 8 if flags & (1 << 11) != 0 # via_bot_id: long
-          offset += 8 if flags2 & 1 != 0           # via_business_bot_id: long
-          return nil if flags & (1 << 3) != 0      # reply_to: variable length
-
-          offset += 4 # date
-          read_tl_string(bytes, offset)
-        end
-
-        def read_tl_string(bytes, offset)
-          first_byte = bytes.getbyte(offset)
-          if first_byte == 254
-            len = bytes.getbyte(offset + 1) |
-                  (bytes.getbyte(offset + 2) << 8) |
-                  (bytes.getbyte(offset + 3) << 16)
-            bytes[offset + 4, len]
-          else
-            bytes[offset + 1, first_byte]
-          end
+          Message.deserialize(bytes, 4, bytes[4, 4].unpack1('L<'))&.text
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../reader'
+require_relative '../peers'
 require_relative 'message'
-require_relative 'dialogs'
 
 module MTProto
   module TL
@@ -37,8 +37,8 @@ module MTProto
         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)
+        users, offset = Peers.users_at(data, offset)
+        chats, = Peers.chats_at(data, offset)
         new(messages: messages, users: users, chats: chats,
           callback_queries: callback_queries, guest_queries: guest_queries)
       end
@@ -105,9 +105,7 @@ module MTProto
         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
+        offset = Reader.schema.skip_vector(data, offset) if flags.anybits?(1 << 0) # reference_messages
         qts = data[offset, 4].unpack1('l<')
 
         { query_id: query_id, message: msg&.to_h, qts: qts }

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../schema'
+require_relative '../reader'
+require_relative '../peers'
 require_relative 'message'
-require_relative 'dialogs'
 require_relative 'updates'
 
 module MTProto
@@ -10,8 +10,6 @@ module MTProto
     class UpdatesDifference
       attr_reader :type, :date, :seq, :new_messages, :pts, :state, :chats, :users, :guest_queries, :managed_bots
 
-      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: [],
                      guest_queries: [], managed_bots: [])
         @type = type
@@ -26,10 +24,6 @@ module MTProto
         @managed_bots = managed_bots
       end
 
-      def self.schema
-        @schema ||= Schema.new(SCHEMA_PATH)
-      end
-
       def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
 
@@ -68,11 +62,12 @@ module MTProto
         def parse_difference(data, constructor)
           offset = 4
 
-          messages, offset = parse_messages_vector(data, offset)
-          offset = schema.skip_vector(data, offset) # new_encrypted_messages
+          raw_messages, offset = Message.vector_at(data, offset)
+          messages = raw_messages.map(&:to_h)
+          offset = Reader.schema.skip_vector(data, offset) # new_encrypted_messages
           other_messages, guest_queries, managed_bots, offset = parse_other_updates(data, offset)
-          chats, offset = Dialogs.chats_at(data, offset)
-          users, offset = Dialogs.users_at(data, offset)
+          chats, offset = Peers.chats_at(data, offset)
+          users, offset = Peers.users_at(data, offset)
           state = UpdatesState.deserialize(data[offset..])
 
           new(
@@ -86,7 +81,7 @@ module MTProto
 
         # other_updates: Vector<Update>. Mine the message-bearing updates
         # (updateNewMessage / updateNewChannelMessage — each is the update ctor,
-        # then an inner Message, then pts/pts_count); advance the rest via schema.
+        # then an inner Message, then pts/pts_count); advance the rest via Reader.schema.
         def parse_other_updates(data, offset)
           offset += 4 # vector constructor
           count = data[offset, 4].unpack1('L<')
@@ -106,25 +101,10 @@ module MTProto
             elsif ctor == UPDATE_MANAGED_BOT
               managed_bots << { user_id: data[offset + 4, 8].unpack1('Q<'), bot_id: data[offset + 12, 8].unpack1('Q<') }
             end
-            offset = schema.skip(data, offset)
+            offset = Reader.schema.skip(data, offset)
           end
           [messages, guest_queries, managed_bots, offset]
         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
       end
     end
   end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'media_parts'
+
+module MTProto
+  module TL
+    # messages.uploadMedia — hand Telegram an upload and get back the photo it now holds.
+    #
+    # The step before an album: a group is sent by naming photos Telegram already has, so
+    # each file is offered once on its own before the group is sent at all.
+    class UploadMedia
+      include MediaParts
+
+      CONSTRUCTOR = 0x14967978
+
+      def initialize(peer:, file:)
+        @peer = peer
+        @file = file
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) + u32_b(0) + serialize_peer(@peer) + serialize_uploaded_photo(@file)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/peers.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require_relative 'reader'
+
+module MTProto
+  module TL
+    module Peers
+      module_function
+
+      Chat = Struct.new(:id, :title, :type, :access_hash, :username, :min, keyword_init: true)
+
+      def chats_at(data, offset)
+        offset += 4 # vector constructor
+        count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        chats = []
+        count.times do
+          chat, offset = parse_chat(data, offset)
+          chats << chat if chat
+        end
+        [chats, offset]
+      end
+
+      def parse_chat(data, offset)
+        constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        case constructor
+        when Constructors::CHAT
+          parse_basic_chat(data, offset)
+        when Constructors::CHANNEL
+          parse_channel(data, offset)
+        when Constructors::CHAT_FORBIDDEN
+          parse_chat_forbidden(data, offset)
+        when Constructors::CHANNEL_FORBIDDEN
+          parse_channel_forbidden(data, offset)
+        when CHAT_EMPTY
+          id = data[offset, 8].unpack1('Q<')
+          offset += 8
+          [Chat.new(id: id, title: '(empty)', type: :chat_empty), offset]
+        else
+          raise "Unknown Chat constructor: 0x#{constructor.to_s(16).rjust(8, '0')}"
+        end
+      end
+
+      CHAT_EMPTY = 0x29562865
+
+      # chat#41cbf256 flags:#
+      #   id:long title:string photo:ChatPhoto
+      #   participants_count:int date:int version:int
+      #   migrated_to:flags.6?InputChannel
+      #   admin_rights:flags.14?ChatAdminRights
+      #   default_banned_rights:flags.18?ChatBannedRights
+      def parse_basic_chat(data, offset)
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        title, offset = Reader.read_tl_string(data, offset)
+        offset = Reader.schema.skip(data, offset) # photo (ChatPhoto)
+        offset += 4 # participants_count
+        offset += 4 # date
+        offset += 4 # version
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 6) # migrated_to (InputChannel)
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 14) # admin_rights
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 18) # default_banned_rights
+
+        [Chat.new(id: id, title: title, type: :chat), offset]
+      end
+
+      # channel#1c32b11c flags:# flags2:#
+      #   id:long access_hash:flags.13?long title:string
+      #   username:flags.6?string photo:ChatPhoto date:int
+      #   restriction_reason:flags.9?Vector<RestrictionReason>
+      #   admin_rights:flags.14?ChatAdminRights
+      #   banned_rights:flags.15?ChatBannedRights
+      #   default_banned_rights:flags.18?ChatBannedRights
+      #   participants_count:flags.17?int
+      #   usernames:flags2.0?Vector<Username>
+      #   stories_max_id:flags2.4?int
+      #   color:flags2.7?PeerColor profile_color:flags2.8?PeerColor
+      #   emoji_status:flags2.9?EmojiStatus
+      #   level:flags2.10?int subscription_until_date:flags2.11?int
+      #   bot_verification_icon:flags2.13?long
+      #   send_paid_messages_stars:flags2.14?long
+      #   linked_monoforum_id:flags2.18?long
+      def parse_channel(data, offset)
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        flags2 = data[offset, 4].unpack1('L<')
+        offset += 4
+        id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        access_hash = nil
+        if flags.anybits?(1 << 13)
+          access_hash = data[offset, 8].unpack1('Q<')
+          offset += 8
+        end
+        title, offset = Reader.read_tl_string(data, offset)
+        username = nil
+        username, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 6) # username
+        offset = Reader.schema.skip(data, offset) # photo (ChatPhoto)
+        offset += 4 # date
+        offset = Reader.schema.skip_vector(data, offset) if flags.anybits?(1 << 9) # restriction_reason
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 14) # admin_rights
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 15) # banned_rights
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 18) # default_banned_rights
+        offset += 4 if flags.anybits?(1 << 17) # participants_count
+        offset = Reader.schema.skip_vector(data, offset) if flags2.anybits?(1 << 0) # usernames Vector<Username>
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 4) # stories_max_id (layer 227: RecentStory)
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 7) # color (PeerColor)
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 8) # profile_color (PeerColor)
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 9) # emoji_status
+        offset += 4 if flags2.anybits?(1 << 10) # level
+        offset += 4 if flags2.anybits?(1 << 11) # subscription_until_date
+        offset += 8 if flags2.anybits?(1 << 13) # bot_verification_icon (long)
+        offset += 8 if flags2.anybits?(1 << 14) # send_paid_messages_stars (long)
+        offset += 8 if flags2.anybits?(1 << 18) # linked_monoforum_id (long)
+
+        type = flags.anybits?(1 << 8) ? :supergroup : :channel
+        [Chat.new(id: id, title: title, type: type, access_hash: access_hash, username: username,
+          min: flags.anybits?(1 << 12)), offset]
+      end
+
+      # chatForbidden#6592a1a7 id:long title:string
+      def parse_chat_forbidden(data, offset)
+        id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        title, offset = Reader.read_tl_string(data, offset)
+        [Chat.new(id: id, title: title, type: :chat_forbidden), offset]
+      end
+
+      # channelForbidden#17d493d5 flags:#
+      #   id:long access_hash:long title:string until_date:flags.16?int
+      def parse_channel_forbidden(data, offset)
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        access_hash = data[offset, 8].unpack1('Q<')
+        offset += 8
+        title, offset = Reader.read_tl_string(data, offset)
+        offset += 4 if flags.anybits?(1 << 16) # until_date
+        [Chat.new(id: id, title: title, type: :channel_forbidden, access_hash: access_hash), offset]
+      end
+
+      def users_at(data, offset)
+        offset += 4 # vector constructor
+        count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        users = []
+        count.times do
+          user, offset = parse_user(data, offset)
+          users << user if user
+        end
+        [users, offset]
+      end
+
+      USER_EMPTY = 0xd3bc4b7a
+
+      # user#31774388 flags:# flags2:#
+      #   id:long access_hash:flags.0?long
+      #   first_name:flags.1?string last_name:flags.2?string
+      #   username:flags.3?string phone:flags.4?string
+      #   photo:flags.5?UserProfilePhoto status:flags.6?UserStatus
+      #   bot_info_version:flags.14?int
+      #   restriction_reason:flags.18?Vector<RestrictionReason>
+      #   bot_inline_placeholder:flags.19?string
+      #   lang_code:flags.22?string
+      #   emoji_status:flags.30?EmojiStatus
+      #   usernames:flags2.0?Vector<Username>
+      #   stories_max_id:flags2.5?int
+      #   color:flags2.8?PeerColor profile_color:flags2.9?PeerColor
+      #   bot_active_users:flags2.12?int
+      #   bot_verification_icon:flags2.14?long
+      #   send_paid_messages_stars:flags2.15?long
+      def parse_user(data, offset)
+        constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        if constructor == USER_EMPTY
+          offset += 8 # id (long)
+          return [nil, offset]
+        end
+
+        raise "Unknown User constructor: 0x#{constructor.to_s(16)}" unless constructor == Constructors::USER
+
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+        flags2 = data[offset, 4].unpack1('L<')
+        offset += 4
+        id = data[offset, 8].unpack1('Q<')
+        offset += 8
+        carries_hash = flags.anybits?(1 << 0)
+        if carries_hash
+          access_hash = data[offset, 8].unpack1('Q<')
+          offset += 8
+        end
+
+        first_name = nil
+        first_name, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 1)
+
+        last_name = nil
+        last_name, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 2)
+
+        username = nil
+        username, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 3) # username
+
+        _, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 4) # phone
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 5) # photo
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 6) # status
+        offset += 4 if flags.anybits?(1 << 14) # bot_info_version
+        offset = Reader.schema.skip_vector(data, offset) if flags.anybits?(1 << 18) # restriction_reason
+        _, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 19) # bot_inline_placeholder
+        _, offset = Reader.read_tl_string(data, offset) if flags.anybits?(1 << 22) # lang_code
+        offset = Reader.schema.skip(data, offset) if flags.anybits?(1 << 30) # emoji_status
+        offset = Reader.schema.skip_vector(data, offset) if flags2.anybits?(1 << 0) # usernames
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 5) # stories_max_id (layer 227: RecentStory)
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 8) # color
+        offset = Reader.schema.skip(data, offset) if flags2.anybits?(1 << 9) # profile_color
+        offset += 4 if flags2.anybits?(1 << 12) # bot_active_users
+        offset += 8 if flags2.anybits?(1 << 14) # bot_verification_icon
+        offset += 8 if flags2.anybits?(1 << 15) # send_paid_messages_stars
+
+        user = { id: id, first_name: first_name, last_name: last_name, username: username,
+                 is_bot: flags.anybits?(1 << 14), min: flags.anybits?(1 << 20) }
+        user[:access_hash] = access_hash if carries_hash
+        [user, offset]
+      end
+      private_class_method :parse_chat, :parse_basic_chat, :parse_channel,
+        :parse_chat_forbidden, :parse_channel_forbidden, :parse_user
+    end
+  end
+end

data/lib/mtproto/tl/reader.rb

@@ -18,6 +18,9 @@ module MTProto
       MEDIA_DOCUMENT = 0x52d8ccd9
       DOCUMENT = 0x8fd4c4d8
       PHOTO = 0xfb197a65
+      PHOTO_SIZE = 0x75c78e60
+      PHOTO_CACHED_SIZE = 0x021e1ad6
+      PHOTO_SIZE_PROGRESSIVE = 0xfa3efb95
       DOCUMENT_ATTRIBUTE_AUDIO = 0x9852f9c6
       DOCUMENT_ATTRIBUTE_FILENAME = 0x15590068
 
@@ -158,13 +161,37 @@ module MTProto
         id = data[offset, 8].unpack1('q<')
         access_hash = data[offset + 8, 8].unpack1('q<')
         offset += 16
-        file_reference, = read_tl_bytes(data, offset)
+        file_reference, offset = read_tl_bytes(data, offset)
 
-        { id: id, access_hash: access_hash, file_reference: file_reference }
+        { id: id, access_hash: access_hash, file_reference: file_reference,
+          sizes: photo_sizes(data, offset + 4) } # +4: date, which precedes the sizes
       rescue StandardError
         nil
       end
 
+      # Every size Telegram holds this photo in, by the name upload.getFile asks for it.
+      #
+      # A photo, unlike a document, is not fetched whole: the location names which size is
+      # wanted, and naming none is answered as if the reference had gone stale — which is
+      # what makes a missing size look like an expired one.
+      #
+      # Only the sizes with a width can be fetched: the other kinds carry their own bytes
+      # inline (a blur, an outline) and have nothing to ask for.
+      SIZES_WITH_WIDTH = [PHOTO_SIZE, PHOTO_CACHED_SIZE, PHOTO_SIZE_PROGRESSIVE].freeze
+
+      def photo_sizes(data, offset)
+        found = []
+        schema.skip_vector(data, offset) do |bytes, at|
+          constructor = bytes[at, 4].unpack1('L<')
+          name, after = read_tl_string(bytes, at + 4)
+          found << { type: name, width: bytes[after, 4].unpack1('l<') } if SIZES_WITH_WIDTH.include?(constructor)
+          schema.skip(bytes, at)
+        end
+        found
+      rescue StandardError
+        []
+      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.