mtproto 0.0.13 → 0.0.15

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

@@ -16,7 +16,7 @@ module MTProto
         !@sign_up_required && @user_id
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
 
         return new(sign_up_required: true) if constructor == Constructors::AUTH_AUTHORIZATION_SIGN_UP_REQUIRED

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # channels.createChannel — create a broadcast channel or, with the megagroup
+    # flag, a supergroup. Returns Updates carrying the new channel.
+    class ChannelsCreateChannel
+      include Binary
+
+      CONSTRUCTOR = 0x91006707
+
+      def initialize(title:, about: '', megagroup: true, broadcast: false)
+        @title = title
+        @about = about
+        @megagroup = megagroup
+        @broadcast = broadcast
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @broadcast
+        flags |= (1 << 1) if @megagroup
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@title)
+        result += serialize_tl_string(@about)
+        result
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.to_s.b.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)
+        [0] * ((4 - (current_length % 4)) % 4)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsDeleteMessages
+      include Binary
+
+      CONSTRUCTOR = 0x84c1fd4e
+
+      def initialize(channel:, ids:)
+        @channel = channel
+        @ids = ids
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_channel
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(id) }
+        result
+      end
+
+      private
+
+      def serialize_input_channel
+        u32_b(Constructors::INPUT_CHANNEL) +
+          u64_b(@channel[:id]) +
+          u64_b(@channel[:access_hash])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsDeleteParticipantHistory
+      include Binary
+
+      CONSTRUCTOR = 0x367544db
+
+      def initialize(channel:, participant:)
+        @channel = channel
+        @participant = participant
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::INPUT_CHANNEL) + u64_b(@channel[:id]) + u64_b(@channel[:access_hash])
+        result += serialize_input_peer(@participant)
+        result
+      end
+
+      private
+
+      def serialize_input_peer(peer)
+        case peer[:type]
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        else
+          raise "Unsupported participant peer type: #{peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsEditBanned
+      include Binary
+
+      CONSTRUCTOR = 0x96e6cd81
+      CHAT_BANNED_RIGHTS = 0x9f120418
+
+      def initialize(channel:, participant:, view_messages: false, send_messages: false, until_date: 0)
+        @channel = channel
+        @participant = participant
+        @view_messages = view_messages
+        @send_messages = send_messages
+        @until_date = until_date
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_channel
+        result += serialize_input_peer(@participant)
+        result += serialize_banned_rights
+        result
+      end
+
+      private
+
+      def serialize_banned_rights
+        flags = 0
+        flags |= (1 << 0) if @view_messages
+        flags |= (1 << 1) if @send_messages
+        u32_b(CHAT_BANNED_RIGHTS) + u32_b(flags) + u32_b(@until_date)
+      end
+
+      def serialize_input_channel
+        u32_b(Constructors::INPUT_CHANNEL) +
+          u64_b(@channel[:id]) +
+          u64_b(@channel[:access_hash])
+      end
+
+      def serialize_input_peer(peer)
+        case peer[:type]
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        else
+          raise "Unsupported participant peer type: #{peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsGetMessages
+      include Binary
+
+      CONSTRUCTOR = 0xad8c9a23
+      INPUT_MESSAGE_ID = 0xa676a322
+
+      def initialize(channel:, ids:)
+        @channel = channel
+        @ids = ids
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_channel
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(INPUT_MESSAGE_ID) + u32_b(id) }
+        result
+      end
+
+      private
+
+      def serialize_input_channel
+        u32_b(Constructors::INPUT_CHANNEL) +
+          u64_b(@channel[:id]) +
+          u64_b(@channel[:access_hash])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsGetParticipant
+      include Binary
+
+      CONSTRUCTOR = 0xa0ab6cc6
+
+      def initialize(channel:, participant:)
+        @channel = channel
+        @participant = participant
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::INPUT_CHANNEL) + u64_b(@channel[:id]) + u64_b(@channel[:access_hash])
+        result += serialize_input_peer(@participant)
+        result
+      end
+
+      private
+
+      def serialize_input_peer(peer)
+        case peer[:type]
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        when :self
+          u32_b(Constructors::INPUT_PEER_SELF)
+        else
+          raise "Unsupported participant peer type: #{peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsJoinChannel
+      include Binary
+
+      CONSTRUCTOR = 0x24b524c5
+
+      def initialize(channel:)
+        @channel = channel
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) +
+          u32_b(Constructors::INPUT_CHANNEL) +
+          u64_b(@channel[:id]) +
+          u64_b(@channel[:access_hash])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsLeaveChannel
+      include Binary
+
+      CONSTRUCTOR = 0xf836aa95
+
+      def initialize(channel:)
+        @channel = channel
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) +
+          u32_b(Constructors::INPUT_CHANNEL) +
+          u64_b(@channel[:id]) +
+          u64_b(@channel[:access_hash])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ChannelsReportSpam
+      include Binary
+
+      CONSTRUCTOR = 0xf44a8315
+
+      def initialize(channel:, participant:, ids:)
+        @channel = channel
+        @participant = participant
+        @ids = ids
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::INPUT_CHANNEL) + u64_b(@channel[:id]) + u64_b(@channel[:access_hash])
+        result += serialize_input_peer(@participant)
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(id) }
+        result
+      end
+
+      private
+
+      def serialize_input_peer(peer)
+        case peer[:type]
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        else
+          raise "Unsupported participant peer type: #{peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module MTProto
         @m1 = m1
       end
 
-      def body
+      def serialize
         u32_b(Constructors::AUTH_CHECK_PASSWORD) +
           u32_b(Constructors::INPUT_CHECK_PASSWORD_SRP) +
           u64_b(@srp_id) +

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

@@ -14,7 +14,7 @@ module MTProto
         @g_b = g_b
       end
 
-      def body
+      def serialize
         result = u32_b(Constructors::CLIENT_DH_INNER_DATA)
         result += @nonce.bytes
         result += @server_nonce.bytes

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative '../schema'
+
+module MTProto
+  module TL
+    class Contacts
+      Contact = Struct.new(:user_id, :mutual, keyword_init: true)
+      User = Struct.new(:id, :first_name, :last_name, :access_hash, keyword_init: true)
+
+      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
+
+      attr_reader :contacts, :saved_count, :users, :not_modified
+
+      def initialize(contacts: [], saved_count: 0, users: [], not_modified: false)
+        @contacts = contacts
+        @saved_count = saved_count
+        @users = users
+        @not_modified = not_modified
+      end
+
+      def not_modified?
+        @not_modified
+      end
+
+      def self.schema
+        @schema ||= Schema.new(SCHEMA_PATH)
+      end
+
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        return new(not_modified: true) if constructor == Constructors::CONTACTS_CONTACTS_NOT_MODIFIED
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::CONTACTS_CONTACTS
+
+        offset = 4
+        contacts, offset = parse_contacts_vector(data, offset)
+        saved_count = data[offset, 4].unpack1('l<')
+        offset += 4
+        users, = parse_users_vector(data, offset)
+
+        new(contacts: contacts, saved_count: saved_count, users: users)
+      end
+
+      USER_EMPTY = 0xd3bc4b7a
+      private_constant :USER_EMPTY
+
+      class << self
+        private
+
+        def parse_contacts_vector(data, offset)
+          offset += 4 # vector tag
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          contacts = []
+          count.times do
+            constructor = data[offset, 4].unpack1('L<')
+            offset += 4
+            raise "Unknown Contact constructor: 0x#{constructor.to_s(16)}" unless constructor == Constructors::CONTACT
+
+            user_id = data[offset, 8].unpack1('Q<')
+            offset += 8
+            mutual_tag = data[offset, 4].unpack1('L<')
+            offset += 4
+            mutual = mutual_tag == Constructors::BOOL_TRUE
+            contacts << Contact.new(user_id: user_id, mutual: mutual)
+          end
+          [contacts, offset]
+        end
+
+        # User parsing mirrors TL::Dialogs.parse_user (user#020b1422). Kept private here
+        # so this class can be used without instantiating Dialogs.
+        def parse_users_vector(data, offset)
+          offset += 4 # vector tag
+          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
+
+        def parse_user(data, offset)
+          constructor = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          if constructor == USER_EMPTY
+            offset += 8
+            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
+          offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) } if flags.anybits?(1 << 18)
+          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)
+          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
+
+          [User.new(id: id, first_name: first_name, last_name: last_name, access_hash: access_hash), offset]
+        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
+
+        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/create_bot.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class CreateBot
+      include Binary
+
+      CONSTRUCTOR = 0xe5b17f2b
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # manager: { id:, access_hash: } or { type: :self }
+      def initialize(name:, username:, manager:, via_deeplink: false)
+        @name = name
+        @username = username
+        @manager = manager
+        @via_deeplink = via_deeplink
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @via_deeplink
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@name)
+        result += serialize_tl_string(@username)
+        result += if @manager[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@manager[:id]) + u64_b(@manager[:access_hash] || 0)
+                  end
+        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/delete_messages.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class DeleteMessages
+      include Binary
+
+      def initialize(ids:, revoke: false)
+        @ids = ids
+        @revoke = revoke
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @revoke
+
+        result = u32_b(Constructors::MESSAGES_DELETE_MESSAGES)
+        result += u32_b(flags)
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(id) }
+        result
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module MTProto
 
       attr_reader :status, :nonce, :server_nonce, :new_nonce_hash
 
-      def self.parse(message)
+      def self.deserialize(message)
         data = message.body
         constructor = b_u32(data[0, 4])
 

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

@@ -5,7 +5,7 @@ require_relative '../schema'
 module MTProto
   module TL
     class Dialogs
-      Dialog = Struct.new(:peer_type, :peer_id, :top_message, :unread_count, keyword_init: true)
+      Dialog = Struct.new(:peer_type, :peer_id, :top_message, :unread_count, :pts, keyword_init: true)
       Chat = Struct.new(:id, :title, :type, :access_hash, keyword_init: true)
 
       SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
@@ -28,7 +28,7 @@ module MTProto
         @schema ||= Schema.new(SCHEMA_PATH)
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
 
         unless [Constructors::MESSAGES_DIALOGS, Constructors::MESSAGES_DIALOGS_SLICE].include?(constructor)
@@ -51,6 +51,16 @@ module MTProto
         new(dialogs: dialogs, chats: chats, users: users, count: count, message_dates: message_dates)
       end
 
+      # Parse a chats:Vector<Chat> / users:Vector<User> at an arbitrary offset.
+      # Reused by UpdatesDifference — the same vectors appear in updates.difference.
+      def self.chats_at(data, offset)
+        parse_chats_vector(data, offset)
+      end
+
+      def self.users_at(data, offset)
+        parse_users_vector(data, offset)
+      end
+
       class << self
         private
 
@@ -97,13 +107,17 @@ module MTProto
 
           offset = schema.skip(data, offset) # notify_settings (PeerNotifySettings)
 
-          offset += 4 if flags.anybits?(1 << 0) # pts
+          pts = nil
+          if flags.anybits?(1 << 0)
+            pts = data[offset, 4].unpack1('L<')
+            offset += 4
+          end
           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]
+            top_message: top_message, unread_count: unread_count, pts: pts), offset]
         end
 
         def parse_peer(data, offset)