mtproto 0.0.13 → 0.0.14

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/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)
@@ -97,13 +97,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)

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class EditMessage
+      include Binary
+
+      def initialize(peer:, id:, message:)
+        @peer = peer
+        @id = id
+        @message = message
+      end
+
+      def serialize
+        flags = 1 << 11 # message field present
+        result = u32_b(Constructors::MESSAGES_EDIT_MESSAGE)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += u32_b(@id)
+        result += serialize_tl_string(@message)
+        result
+      end
+
+      private
+
+      def serialize_input_peer
+        case @peer[:type]
+        when :self
+          u32_b(Constructors::INPUT_PEER_SELF)
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(@peer[:id]) + u64_b(@peer[:access_hash] || 0)
+        when :chat
+          u32_b(Constructors::INPUT_PEER_CHAT) + u64_b(@peer[:id])
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(@peer[:id]) + u64_b(@peer[:access_hash] || 0)
+        else
+          raise "Unknown peer type: #{@peer[:type]}"
+        end
+      end
+
+      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/export_login_token.rb

@@ -13,7 +13,7 @@ module MTProto
         @except_ids = except_ids
       end
 
-      def body
+      def serialize
         u32_b(Constructors::AUTH_EXPORT_LOGIN_TOKEN) +
           u32_b(@api_id) +
           serialize_tl_string(@api_hash) +

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    class ForwardMessages
+      include Binary
+
+      CONSTRUCTOR = 0x978928ca
+
+      def initialize(from_peer:, to_peer:, ids:, random_ids: nil)
+        @from_peer = from_peer
+        @to_peer = to_peer
+        @ids = ids
+        @random_ids = random_ids || Array.new(ids.length) { SecureRandom.random_number(2**63) }
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(0) # flags
+        result += serialize_input_peer(@from_peer)
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(id) }
+        result += u32_b(Constructors::VECTOR) + u32_b(@random_ids.length)
+        @random_ids.each { |rid| result += u64_b(rid) }
+        result += serialize_input_peer(@to_peer)
+        result
+      end
+
+      private
+
+      def serialize_input_peer(peer)
+        case peer[:type]
+        when :self
+          u32_b(Constructors::INPUT_PEER_SELF)
+        when :user
+          u32_b(Constructors::INPUT_PEER_USER) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        when :chat
+          u32_b(Constructors::INPUT_PEER_CHAT) + u64_b(peer[:id])
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(peer[:id]) + u64_b(peer[:access_hash] || 0)
+        else
+          raise "Unknown peer type: #{peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetChannelDifference
+      include Binary
+
+      def initialize(channel:, pts:, limit: 100, force: false)
+        @channel = channel
+        @pts = pts
+        @limit = limit
+        @force = force
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @force
+
+        result = u32_b(Constructors::UPDATES_GET_CHANNEL_DIFFERENCE)
+        result += u32_b(flags)
+        result += serialize_input_channel
+        result += u32_b(Constructors::CHANNEL_MESSAGES_FILTER_EMPTY)
+        result += u32_b(@pts)
+        result += u32_b(@limit)
+        result
+      end
+
+      private
+
+      def serialize_input_channel
+        if @channel.nil? || @channel[:type] == :empty
+          u32_b(Constructors::INPUT_CHANNEL_EMPTY)
+        else
+          u32_b(Constructors::INPUT_CHANNEL) +
+            u64_b(@channel[:id]) +
+            u64_b(@channel[:access_hash])
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module MTProto
     class GetConfig
       include Binary
 
-      def body
+      def serialize
         u32_b(Constructors::HELP_GET_CONFIG)
       end
     end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetContacts
+      include Binary
+
+      def initialize(hash: 0)
+        @hash = hash
+      end
+
+      def serialize
+        u32_b(Constructors::CONTACTS_GET_CONTACTS) + u64_b(@hash)
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module MTProto
         @folder_id = folder_id
       end
 
-      def body
+      def serialize
         flags = 0
         flags |= (1 << 0) if @exclude_pinned
         flags |= (1 << 1) if @folder_id

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

@@ -16,7 +16,7 @@ module MTProto
         @qts_limit = qts_limit
       end
 
-      def body
+      def serialize
         flags = 0
         flags |= (1 << 0) if @pts_limit
         flags |= (1 << 1) if @pts_total_limit

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetFile
+      include Binary
+
+      CONSTRUCTOR = 0xbe5335be
+      INPUT_PHOTO_FILE_LOCATION = 0x40181ffe
+
+      # location: { id:, access_hash:, file_reference: (binary String), thumb_size: (String) }
+      def initialize(location:, offset: 0, limit: 1024 * 1024)
+        @location = location
+        @offset = offset
+        @limit = limit
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(0) # flags
+        result += serialize_location
+        result += u64_b(@offset)
+        result += u32_b(@limit)
+        result
+      end
+
+      private
+
+      def serialize_location
+        u32_b(INPUT_PHOTO_FILE_LOCATION) +
+          u64_b(@location[:id]) +
+          u64_b(@location[:access_hash]) +
+          serialize_tl_bytes(@location[:file_reference]) +
+          serialize_tl_bytes(@location[:thumb_size])
+      end
+
+      def serialize_tl_bytes(value)
+        bytes = value.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)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end