mtproto 0.0.9 → 0.0.11

data/lib/mtproto/tl/object.rb

@@ -15,7 +15,7 @@ module MTProto
       def self.parse(message)
         body = message.body
         constructor_id = b_u32(body[0, 4])
-        constructor = Constructors::NAMES.fetch(constructor_id)
+        constructor = ConstructorNames::NAMES.fetch(constructor_id)
         payload = body[4..]
 
         new(constructor, payload)

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

@@ -3,9 +3,6 @@
 module MTProto
   module TL
     class AccountPassword
-      CONSTRUCTOR = 0x957b50fb
-      ALGO_SHA256_MOD_POW = 0x3a912d4a
-
       attr_reader :has_password, :current_algo, :srp_b, :srp_id
 
       def initialize(has_password:, current_algo: nil, srp_b: nil, srp_id: nil)
@@ -17,7 +14,7 @@ module MTProto
 
       def self.parse(data)
         constructor = data[0, 4].unpack1('L<')
-        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::ACCOUNT_PASSWORD
 
         offset = 4
         flags = data[offset, 4].unpack1('L<')
@@ -31,7 +28,7 @@ module MTProto
         offset += 4
 
         current_algo = nil
-        if algo_constructor == ALGO_SHA256_MOD_POW
+        if algo_constructor == Constructors::PASSWORD_KDF_ALGO_SHA256_MOD_POW
           salt1, offset = read_tl_bytes(data, offset)
           salt2, offset = read_tl_bytes(data, offset)
           g = data[offset, 4].unpack1('l<')

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

@@ -3,9 +3,6 @@
 module MTProto
   module TL
     class Authorization
-      CONSTRUCTOR = 0x2ea2c0d4
-      CONSTRUCTOR_SIGN_UP_REQUIRED = 0x44747e9a
-
       attr_reader :user_id, :access_hash, :flags, :sign_up_required
 
       def initialize(user_id: nil, access_hash: nil, flags: 0, sign_up_required: false)
@@ -22,8 +19,8 @@ module MTProto
       def self.parse(data)
         constructor = data[0, 4].unpack1('L<')
 
-        return new(sign_up_required: true) if constructor == CONSTRUCTOR_SIGN_UP_REQUIRED
-        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+        return new(sign_up_required: true) if constructor == Constructors::AUTH_AUTHORIZATION_SIGN_UP_REQUIRED
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::AUTH_AUTHORIZATION
 
         offset = 4
 

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

@@ -5,9 +5,6 @@ module MTProto
     class CheckPassword
       include Binary
 
-      CONSTRUCTOR = 0xd18b4d16
-      INPUT_CHECK_PASSWORD_SRP = 0xd27ff082
-
       attr_reader :srp_id, :a, :m1
 
       def initialize(srp_id:, a:, m1:)
@@ -17,8 +14,8 @@ module MTProto
       end
 
       def body
-        u32_b(CONSTRUCTOR) +
-          u32_b(INPUT_CHECK_PASSWORD_SRP) +
+        u32_b(Constructors::AUTH_CHECK_PASSWORD) +
+          u32_b(Constructors::INPUT_CHECK_PASSWORD_SRP) +
           u64_b(@srp_id) +
           serialize_tl_bytes(@a) +
           serialize_tl_bytes(@m1)

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

@@ -5,8 +5,6 @@ module MTProto
     class ClientDHInnerData
       include Binary
 
-      CONSTRUCTOR = 0x6643b654
-
       attr_reader :nonce, :server_nonce, :retry_id, :g_b
 
       def initialize(nonce:, server_nonce:, retry_id:, g_b:)
@@ -17,7 +15,7 @@ module MTProto
       end
 
       def body
-        result = u32_b(CONSTRUCTOR)
+        result = u32_b(Constructors::CLIENT_DH_INNER_DATA)
         result += @nonce.bytes
         result += @server_nonce.bytes
         result += u64_b(@retry_id)

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

@@ -5,10 +5,6 @@ module MTProto
     class DHGenResponse
       extend Binary
 
-      CONSTRUCTOR_OK = 0x3bcbf734
-      CONSTRUCTOR_RETRY = 0x46dc1fb9
-      CONSTRUCTOR_FAIL = 0xa69dae02
-
       attr_reader :status, :nonce, :server_nonce, :new_nonce_hash
 
       def self.parse(message)
@@ -16,9 +12,9 @@ module MTProto
         constructor = b_u32(data[0, 4])
 
         status = case constructor
-                 when CONSTRUCTOR_OK then :ok
-                 when CONSTRUCTOR_RETRY then :retry
-                 when CONSTRUCTOR_FAIL then :fail
+                 when Constructors::DH_GEN_OK then :ok
+                 when Constructors::DH_GEN_RETRY then :retry
+                 when Constructors::DH_GEN_FAIL then :fail
                  else raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
                  end
 

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

@@ -0,0 +1,453 @@
+# frozen_string_literal: true
+
+require_relative '../schema'
+
+module MTProto
+  module TL
+    class Dialogs
+      Dialog = Struct.new(:peer_type, :peer_id, :top_message, :unread_count, keyword_init: true)
+      Chat = Struct.new(:id, :title, :type, :access_hash, keyword_init: true)
+
+      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
+
+      attr_reader :dialogs, :chats, :users, :count, :message_dates
+
+      def initialize(dialogs:, chats:, users:, count: nil, message_dates: {})
+        @dialogs = dialogs
+        @chats = chats
+        @users = users
+        @count = count
+        @message_dates = message_dates
+      end
+
+      def slice?
+        !@count.nil?
+      end
+
+      def self.schema
+        @schema ||= Schema.new(SCHEMA_PATH)
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        unless [Constructors::MESSAGES_DIALOGS, Constructors::MESSAGES_DIALOGS_SLICE].include?(constructor)
+          raise UnexpectedConstructorError, constructor
+        end
+
+        offset = 4
+
+        count = nil
+        if constructor == Constructors::MESSAGES_DIALOGS_SLICE
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+        end
+
+        dialogs, offset = parse_dialogs_vector(data, offset)
+        message_dates, offset = parse_messages_vector(data, offset)
+        chats, offset = parse_chats_vector(data, offset)
+        users, = parse_users_vector(data, offset)
+
+        new(dialogs: dialogs, chats: chats, users: users, count: count, message_dates: message_dates)
+      end
+
+      class << self
+        private
+
+        # --- Dialogs vector ---
+
+        def parse_dialogs_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          dialogs = []
+          count.times do
+            dialog, offset = parse_dialog(data, offset)
+            dialogs << dialog if dialog
+          end
+          [dialogs, offset]
+        end
+
+        def parse_dialog(data, offset)
+          constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          unless constructor == Constructors::DIALOG
+            offset = schema.skip_params(data, offset, constructor)
+            return [nil, offset]
+          end
+
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          peer_type, peer_id, offset = parse_peer(data, offset)
+
+          top_message = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          offset += 4 # read_inbox_max_id
+          offset += 4 # read_outbox_max_id
+
+          unread_count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          offset += 4 # unread_mentions_count
+          offset += 4 # unread_reactions_count
+
+          offset = schema.skip(data, offset) # notify_settings (PeerNotifySettings)
+
+          offset += 4 if flags.anybits?(1 << 0) # pts
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 1) # draft (DraftMessage)
+          offset += 4 if flags.anybits?(1 << 4) # folder_id
+          offset += 4 if flags.anybits?(1 << 5) # ttl_period
+
+          [Dialog.new(peer_type: peer_type, peer_id: peer_id,
+            top_message: top_message, unread_count: unread_count), 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
+
+        # --- Messages vector ---
+
+        # message#9815cec8 flags:# flags2:#
+        #   id:int from_id:flags.8?Peer from_boosts_applied:flags.29?int
+        #   peer_id:Peer saved_peer_id:flags.28?Peer
+        #   fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?long
+        #   via_business_bot_id:flags2.0?long reply_to:flags.3?MessageReplyHeader
+        #   date:int ...
+        #
+        # messageService#2b085862 flags:#
+        #   id:int from_id:flags.8?Peer peer_id:Peer
+        #   saved_peer_id:flags.28?Peer reply_to:flags.3?MessageReplyHeader
+        #   date:int ...
+        MESSAGE_CONSTRUCTOR = Constructors::MESSAGE
+        MESSAGE_SERVICE = 0x7a800e0a
+        MESSAGE_EMPTY = 0x90a6ca84
+
+        def parse_messages_vector(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          dates = {}
+          count.times do
+            constructor = data[offset, 4].unpack1('L<')
+            id_date = extract_message_id_date(data, offset, constructor)
+            dates[id_date[0]] = id_date[1] if id_date
+
+            offset = schema.skip(data, offset)
+          end
+          [dates, offset]
+        end
+
+        def extract_message_id_date(data, offset, constructor)
+          case constructor
+          when MESSAGE_CONSTRUCTOR
+            extract_message_date(data, offset)
+          when MESSAGE_SERVICE
+            extract_message_service_date(data, offset)
+          end
+        end
+
+        def extract_message_date(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
+
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          offset = schema.skip(data, offset) # peer_id (Peer, always present)
+          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<')
+          [id, date]
+        end
+
+        def extract_message_service_date(data, offset)
+          offset += 4 # constructor
+          flags = 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 = schema.skip(data, offset) # peer_id (Peer, always present)
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
+
+          date = data[offset, 4].unpack1('L<')
+          [id, date]
+        end
+
+        # --- Chats vector ---
+
+        def parse_chats_vector(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 = read_tl_string(data, offset)
+          offset = schema.skip(data, offset) # photo (ChatPhoto)
+          offset += 4 # participants_count
+          offset += 4 # date
+          offset += 4 # version
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 6) # migrated_to (InputChannel)
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 14) # admin_rights
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 18) # default_banned_rights
+
+          [Chat.new(id: id, title: title, type: :chat), offset]
+        end
+
+        # channel#fe685355 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 = read_tl_string(data, offset)
+          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 6) # username
+          offset = schema.skip(data, offset) # photo (ChatPhoto)
+          offset += 4 # date
+          if flags.anybits?(1 << 9) # restriction_reason Vector<RestrictionReason>
+            offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) }
+          end
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 14) # admin_rights
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 15) # banned_rights
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 18) # default_banned_rights
+          offset += 4 if flags.anybits?(1 << 17) # participants_count
+          if flags2.anybits?(1 << 0) # usernames Vector<Username>
+            offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) }
+          end
+          offset += 4 if flags2.anybits?(1 << 4) # stories_max_id
+          offset = schema.skip(data, offset) if flags2.anybits?(1 << 7) # color (PeerColor)
+          offset = schema.skip(data, offset) if flags2.anybits?(1 << 8) # profile_color (PeerColor)
+          offset = 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), offset]
+        end
+
+        # chatForbidden#6592a1a7 id:long title:string
+        def parse_chat_forbidden(data, offset)
+          id = data[offset, 8].unpack1('Q<')
+          offset += 8
+          title, offset = 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 = 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
+
+        # --- Users vector ---
+
+        def parse_users_vector(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#020b1422 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
+          access_hash = nil
+          if flags.anybits?(1 << 0)
+            access_hash = data[offset, 8].unpack1('Q<')
+            offset += 8
+          end
+
+          first_name = nil
+          first_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 1)
+
+          last_name = nil
+          last_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 2)
+
+          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 3) # username
+          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 4) # phone
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 5) # photo
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 6) # status
+          offset += 4 if flags.anybits?(1 << 14) # bot_info_version
+          if flags.anybits?(1 << 18) # restriction_reason
+            offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) }
+          end
+          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 19) # bot_inline_placeholder
+          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 22) # lang_code
+          offset = schema.skip(data, offset) if flags.anybits?(1 << 30) # emoji_status
+          offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) } if flags2.anybits?(1 << 0) # usernames
+          offset += 4 if flags2.anybits?(1 << 5) # stories_max_id
+          offset = schema.skip(data, offset) if flags2.anybits?(1 << 8) # color
+          offset = 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
+
+          [{ id: id, first_name: first_name, last_name: last_name, access_hash: access_hash }, offset]
+        end
+
+        # --- TL string ---
+
+        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
+
+        def skip_tl_string(data, offset)
+          _, new_offset = read_tl_string(data, offset)
+          new_offset
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,6 @@ module MTProto
     class ExportLoginToken
       include Binary
 
-      CONSTRUCTOR = 0xb7e085fe
-      VECTOR_CONSTRUCTOR = 0x1cb5c415
-
       attr_reader :api_id, :api_hash, :except_ids
 
       def initialize(api_id:, api_hash:, except_ids: [])
@@ -17,7 +14,7 @@ module MTProto
       end
 
       def body
-        u32_b(CONSTRUCTOR) +
+        u32_b(Constructors::AUTH_EXPORT_LOGIN_TOKEN) +
           u32_b(@api_id) +
           serialize_tl_string(@api_hash) +
           serialize_vector_long(@except_ids)
@@ -26,7 +23,7 @@ module MTProto
       private
 
       def serialize_vector_long(ids)
-        result = u32_b(VECTOR_CONSTRUCTOR) + u32_b(ids.length)
+        result = u32_b(Constructors::VECTOR) + u32_b(ids.length)
         ids.each { |id| result += u64_b(id) }
         result
       end

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

@@ -5,10 +5,8 @@ module MTProto
     class GetConfig
       include Binary
 
-      CONSTRUCTOR = 0xc4f9186b
-
       def body
-        u32_b(CONSTRUCTOR)
+        u32_b(Constructors::HELP_GET_CONFIG)
       end
     end
   end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetDialogs
+      include Binary
+
+      attr_reader :offset_date, :offset_id, :offset_peer, :limit, :exclude_pinned, :folder_id
+
+      def initialize(offset_date: 0, offset_id: 0, offset_peer: nil, limit: 100, exclude_pinned: false, folder_id: nil)
+        @offset_date = offset_date
+        @offset_id = offset_id
+        @offset_peer = offset_peer
+        @limit = limit
+        @exclude_pinned = exclude_pinned
+        @folder_id = folder_id
+      end
+
+      def body
+        flags = 0
+        flags |= (1 << 0) if @exclude_pinned
+        flags |= (1 << 1) if @folder_id
+
+        result = u32_b(Constructors::MESSAGES_GET_DIALOGS) + u32_b(flags)
+        result += u32_b(@folder_id) if @folder_id
+        result += u32_b(@offset_date) + u32_b(@offset_id)
+        result += serialize_input_peer
+        result += u32_b(@limit)
+        result += u64_b(0) # hash
+        result
+      end
+
+      private
+
+      def serialize_input_peer
+        return u32_b(Constructors::INPUT_PEER_EMPTY) unless @offset_peer
+
+        case @offset_peer[:type]
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(@offset_peer[:id]) + u64_b(@offset_peer[:access_hash] || 0)
+        when :chat
+          u32_b(Constructors::INPUT_PEER_CHAT) + u64_b(@offset_peer[:id])
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(@offset_peer[:id]) + u64_b(@offset_peer[:access_hash] || 0)
+        else
+          u32_b(Constructors::INPUT_PEER_EMPTY)
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,6 @@ module MTProto
     class GetDifference
       include Binary
 
-      CONSTRUCTOR = 0x19c2f763
-
       attr_reader :pts, :date, :qts, :pts_limit, :pts_total_limit, :qts_limit
 
       def initialize(pts:, date:, qts:, pts_limit: nil, pts_total_limit: nil, qts_limit: nil)
@@ -24,7 +22,7 @@ module MTProto
         flags |= (1 << 1) if @pts_total_limit
         flags |= (1 << 2) if @qts_limit
 
-        result = u32_b(CONSTRUCTOR) + u32_b(flags) + u32_b(@pts)
+        result = u32_b(Constructors::UPDATES_GET_DIFFERENCE) + u32_b(flags) + u32_b(@pts)
         result += u32_b(@pts_limit) if @pts_limit
         result += u32_b(@pts_total_limit) if @pts_total_limit
         result += u32_b(@date) + u32_b(@qts)