mtproto 0.0.14 → 0.0.17

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,21 +1,28 @@
 # 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
+      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)
+      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil, chats: [], users: [],
+                     guest_queries: [])
         @type = type
         @date = date
         @seq = seq
         @new_messages = new_messages
         @pts = pts
         @state = state
+        @chats = chats
+        @users = users
+        @guest_queries = guest_queries
       end
 
       def self.schema
@@ -38,9 +45,8 @@ module MTProto
         end
       end
 
-      MESSAGE_CONSTRUCTOR = Constructors::MESSAGE
-      MESSAGE_SERVICE = 0x7a800e0a
-      MESSAGE_EMPTY = 0x90a6ca84
+      UPDATE_NEW_MESSAGE = 0x1f2b0afd
+      UPDATE_NEW_CHANNEL_MESSAGE = 0x62ba04d9
 
       class << self
         private
@@ -53,95 +59,65 @@ module MTProto
           )
         end
 
-        # updates.difference: new_messages new_encrypted_messages other_updates chats users state
+        # updates.difference: new_messages new_encrypted_messages other_updates chats users state.
+        # Channel/supergroup messages arrive in other_updates as
+        # updateNewChannelMessage (not in new_messages), so we mine those too; and
+        # chats/users carry the peers' access_hashes for the bot's peer cache.
         def parse_difference(data, constructor)
           offset = 4
 
           messages, offset = parse_messages_vector(data, offset)
           offset = schema.skip_vector(data, offset) # new_encrypted_messages
-          offset = schema.skip_vector(data, offset) # other_updates
-          offset = schema.skip_vector(data, offset) # chats
-          offset = schema.skip_vector(data, offset) # users
+          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..])
 
           new(
             type: constructor == Constructors::UPDATES_DIFFERENCE ? :difference : :slice,
-            new_messages: messages,
-            state: state
+            new_messages: messages + other_messages,
+            guest_queries: guest_queries,
+            chats: chats, users: users, state: state
           )
         end
 
-        def parse_messages_vector(data, offset)
+        # 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.
+        def parse_other_updates(data, offset)
           offset += 4 # vector constructor
           count = data[offset, 4].unpack1('L<')
           offset += 4
 
           messages = []
+          guest_queries = []
           count.times do
-            constructor = data[offset, 4].unpack1('L<')
-            msg = extract_message(data, offset, constructor)
-            messages << msg if msg
+            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
+            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]
-        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
-
-          offset = schema.skip(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
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
-
-          date = data[offset, 4].unpack1('L<')
-          offset += 4
-          message_text, = read_tl_string(data, offset)
-
-          { id: id, date: date, message: message_text, peer_type: peer_type, peer_id: peer_id }
+          [messages, guest_queries, offset]
         end
 
-        def parse_peer(data, offset)
-          constructor = data[offset, 4].unpack1('L<')
+        def parse_messages_vector(data, offset)
+          offset += 4 # vector constructor
+          count = 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
+          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
-          padding = (4 - (total % 4)) % 4
-          [data[offset + (total - len), len].force_encoding('UTF-8'), offset + total + padding]
+          [messages, offset]
         end
       end
     end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UploadProfilePhoto
+      include Binary
+
+      CONSTRUCTOR = 0x0388a3b5
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+      INPUT_FILE = 0xf52ff27f
+
+      # bot: { id:, access_hash: } or { type: :self }; nil targets the calling bot
+      # file: { id:, parts:, name:, md5_checksum: }
+      def initialize(file:, bot: nil)
+        @bot = bot
+        @file = file
+      end
+
+      def serialize
+        flags = (1 << 0) # file
+        flags |= (1 << 5) if @bot
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot) if @bot
+        result += serialize_input_file(@file)
+        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_input_file(file)
+        u32_b(INPUT_FILE) +
+          u64_b(file[:id]) +
+          u32_b(file[:parts]) +
+          serialize_tl_string(file[:name].to_s) +
+          serialize_tl_string(file[:md5_checksum].to_s)
+      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/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)

data/lib/mtproto/unencrypted_message.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MTProto
+  # The unencrypted MTProto transport envelope (auth_key_id=0 | msg_id | len | body),
+  # used for the plaintext request/response of the DH key exchange. Its encrypted
+  # sibling is EncryptedMessage; the runtime never decrypts through this class.
+  class UnencryptedMessage
+    include Binary
+    extend Binary
+
+    attr_reader :auth_key_id, :msg_id, :body
+
+    def initialize(body, msg_id: self.class.generate_msg_id, auth_key_id: 0)
+      @auth_key_id = auth_key_id
+      @msg_id = msg_id
+      @body = body
+    end
+
+    def self.parse(packet)
+      data = packet.data
+      msg_id = b_u64(data[8, 8])
+      body_length = b_u32(data[16, 4])
+      body = data[20, body_length]
+
+      new(body, msg_id: msg_id, auth_key_id: 0)
+    end
+
+    def bytes
+      u64_b(@auth_key_id) +
+        u64_b(@msg_id) +
+        u32_b(@body.length) +
+        @body
+    end
+
+    def self.generate_msg_id
+      (Time.now.to_f * (2**32)).to_i & ~3
+    end
+  end
+end

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.14'
+  VERSION = '0.0.17'
 end

data/lib/mtproto.rb

@@ -9,13 +9,15 @@ require_relative 'mtproto/transport/packet'
 require_relative 'mtproto/transport/abridged_packet_codec'
 require_relative 'mtproto/transport/tcp_connection'
 require_relative 'mtproto/transport/connection'
-require_relative 'mtproto/message/message'
+require_relative 'mtproto/unencrypted_message'
 require_relative 'mtproto/tl/constructors'
 require_relative 'mtproto/tl/constructor_names'
+require_relative 'mtproto/tl/reader'
 require_relative 'mtproto/tl/object'
 require_relative 'mtproto/tl/objects/update'
 require_relative 'mtproto/tl/objects/update_short'
 require_relative 'mtproto/tl/objects/update_short_message'
+require_relative 'mtproto/tl/objects/updates'
 require_relative 'mtproto/tl/objects/message'
 require_relative 'mtproto/tl/objects/msg_container'
 require_relative 'mtproto/tl/objects/new_session_created'
@@ -33,6 +35,7 @@ require_relative 'mtproto/auth_key_generator'
 require_relative 'mtproto/session'
 require_relative 'mtproto/encrypted_message'
 require_relative 'mtproto/client'
+require_relative 'mtproto/file_downloader'
 
 module MTProto
 end