mtproto 0.0.13 → 0.0.15

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class EditAccessSettings
+      include Binary
+
+      CONSTRUCTOR = 0x31813cd8
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot / add_users entries: { id:, access_hash: } or { type: :self }
+      def initialize(bot:, restricted: false, add_users: [])
+        @bot = bot
+        @restricted = restricted
+        @add_users = add_users
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @restricted
+        flags |= (1 << 1) unless @add_users.empty?
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot)
+        unless @add_users.empty?
+          result += u32_b(Constructors::VECTOR)
+          result += u32_b(@add_users.size)
+          @add_users.each { |u| result += serialize_input_user(u) }
+        end
+        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
+    end
+  end
+end

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_bot_token.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportBotToken
+      include Binary
+
+      CONSTRUCTOR = 0xbd0d99eb
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+      BOOL_TRUE = 0x997275b5
+      BOOL_FALSE = 0xbc799737
+
+      # bot: { id:, access_hash: } or { type: :self }
+      def initialize(bot:, revoke: false)
+        @bot = bot
+        @revoke = revoke
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += if @bot[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@bot[:id]) + u64_b(@bot[:access_hash] || 0)
+                  end
+        result += u32_b(@revoke ? BOOL_TRUE : BOOL_FALSE)
+        result
+      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/exported_bot_token.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportedBotToken
+      CONSTRUCTOR = 0x3c60b621
+
+      attr_reader :token
+
+      def initialize(token:)
+        @token = token
+      end
+
+      def self.deserialize(bytes)
+        body = bytes[4..]
+        first = body.getbyte(0)
+        token = if first == 254
+                  len = body.getbyte(1) | (body.getbyte(2) << 8) | (body.getbyte(3) << 16)
+                  body[4, len]
+                else
+                  body[1, first]
+                end
+        new(token: token.force_encoding('UTF-8'))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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, drop_author: false, drop_media_captions: false)
+        @from_peer = from_peer
+        @to_peer = to_peer
+        @ids = ids
+        @random_ids = random_ids || Array.new(ids.length) { SecureRandom.random_number(2**63) }
+        @drop_author = drop_author
+        @drop_media_captions = drop_media_captions
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 11) if @drop_author
+        flags |= (1 << 12) if @drop_media_captions
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(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_access_settings.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetAccessSettings
+      include Binary
+
+      CONSTRUCTOR = 0x213853a3
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot: { id:, access_hash: } or { type: :self }
+      def initialize(bot:)
+        @bot = bot
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += if @bot[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@bot[:id]) + u64_b(@bot[:access_hash] || 0)
+                  end
+        result
+      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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetFullChannel
+      include Binary
+
+      CONSTRUCTOR = 0x08736a09
+
+      def initialize(channel:)
+        @channel = channel
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_channel
+        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/get_full_user.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetFullUser
+      include Binary
+
+      CONSTRUCTOR = 0xb60f5918
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # user: { id:, access_hash: } or { type: :self }
+      def initialize(user:)
+        @user = user
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += 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
+        result
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module MTProto
         @min_id = min_id
       end
 
-      def body
+      def serialize
         result = u32_b(CONSTRUCTOR)
         result += serialize_input_peer
         result += u32_b(@offset_id)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetMessagesReactions
+      include Binary
+
+      CONSTRUCTOR = 0x8bba90e6
+
+      def initialize(peer:, ids:)
+        @peer = peer
+        @ids = ids
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_peer
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(id) }
+        result
+      end
+
+      private
+
+      def serialize_input_peer
+        case @peer[:type]
+        when :channel
+          u32_b(Constructors::INPUT_PEER_CHANNEL) + u64_b(@peer[:id]) + u64_b(@peer[:access_hash] || 0)
+        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])
+        else
+          raise "Unknown peer type: #{@peer[:type]}"
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -5,7 +5,7 @@ module MTProto
     class GetUsers
       include Binary
 
-      def body
+      def serialize
         u32_b(Constructors::USERS_GET_USERS) +
           u32_b(Constructors::VECTOR) +
           u32_b(1) +

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

@@ -14,7 +14,7 @@ module MTProto
         @dc_options = dc_options
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
         unless [Constructors::CONFIG, Constructors::GZIP_PACKED].include?(constructor)
           raise UnexpectedConstructorError, constructor

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ImportBotAuthorization
+      include Binary
+
+      CONSTRUCTOR = 0x67a3ff2c
+
+      def initialize(api_id:, api_hash:, bot_auth_token:)
+        @api_id = api_id
+        @api_hash = api_hash
+        @bot_auth_token = bot_auth_token
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(0) # flags (int, unused)
+        result += u32_b(@api_id)
+        result += serialize_tl_string(@api_hash)
+        result += serialize_tl_string(@bot_auth_token)
+        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)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module MTProto
         @token = token
       end
 
-      def body
+      def serialize
         u32_b(Constructors::AUTH_IMPORT_LOGIN_TOKEN) + serialize_tl_bytes(@token)
       end
 

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

@@ -20,7 +20,7 @@ module MTProto
         @query = query
       end
 
-      def body
+      def serialize
         flags = 0
 
         result = u32_b(Constructors::INIT_CONNECTION)
@@ -32,7 +32,7 @@ module MTProto
         result += serialize_tl_string(@system_lang_code)
         result += serialize_tl_string(@lang_pack)
         result += serialize_tl_string(@lang_code)
-        result + @query.body
+        result + @query.serialize
       end
 
       private

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InputKeyboardButtonRequestPeer
+      include Binary
+
+      CONSTRUCTOR = 0x02b78156
+
+      def initialize(text:, button_id:, peer_type:, max_quantity: 1,
+                     name_requested: false, username_requested: false, photo_requested: false)
+        @text = text
+        @button_id = button_id
+        @peer_type = peer_type
+        @max_quantity = max_quantity
+        @name_requested = name_requested
+        @username_requested = username_requested
+        @photo_requested = photo_requested
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @name_requested
+        flags |= (1 << 1) if @username_requested
+        flags |= (1 << 2) if @photo_requested
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@text)
+        result += u32_b(@button_id)
+        result += @peer_type.serialize
+        result += u32_b(@max_quantity)
+        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