mtproto 0.0.13 → 0.0.14

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/invite_to_channel.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InviteToChannel
+      include Binary
+
+      CONSTRUCTOR = 0xc9e33d54
+      INPUT_USER = 0xf21158c6
+
+      def initialize(channel:, users:)
+        @channel = channel
+        @users = users
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += serialize_input_channel
+        result += u32_b(Constructors::VECTOR) + u32_b(@users.length)
+        @users.each do |u|
+          result += u32_b(INPUT_USER) + u64_b(u[:id]) + u64_b(u[:access_hash] || 0)
+        end
+        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/invoke_with_layer.rb

@@ -12,8 +12,8 @@ module MTProto
         @query = query
       end
 
-      def body
-        u32_b(Constructors::INVOKE_WITH_LAYER) + u32_b(@layer) + @query.body
+      def serialize
+        u32_b(Constructors::INVOKE_WITH_LAYER) + u32_b(@layer) + @query.serialize
       end
     end
   end

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

@@ -27,7 +27,7 @@ module MTProto
         @type == :success
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
 
         case constructor
@@ -36,7 +36,7 @@ module MTProto
         when Constructors::AUTH_LOGIN_TOKEN_MIGRATE_TO
           parse_migrate_to(data)
         when Constructors::AUTH_LOGIN_TOKEN_SUCCESS
-          new(type: :success, authorization: Authorization.parse(data[4..]))
+          new(type: :success, authorization: Authorization.deserialize(data[4..]))
         else
           raise UnexpectedConstructorError, constructor
         end

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

@@ -34,7 +34,7 @@ module MTProto
         )
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
         raise UnexpectedConstructorError, constructor unless VALID_CONSTRUCTORS.include?(constructor)
 

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

@@ -18,7 +18,7 @@ module MTProto
         @expires_in = expires_in
       end
 
-      def body
+      def serialize
         constructor = @expires_in ? Constructors::PQ_INNER_DATA_TEMP_DC : Constructors::PQ_INNER_DATA_DC
 
         result = u32_b(constructor)

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../constructor_names'
+
+module MTProto
+  module TL
+    # Pseudo TL object used as response_class when we want rpc.call to hand
+    # back the raw bytes of whatever the server returns, without imposing a
+    # specific TL schema. Useful when a method can legally return one of
+    # several constructor variants (e.g. messages.sendMessage may return
+    # updateShortSentMessage, updates, or updatesCombined depending on
+    # context) and we just want to capture the wire bytes for fixtures.
+    class RawResponse
+      attr_reader :raw_bytes, :constructor_id, :constructor_name
+
+      def initialize(raw_bytes:, constructor_id:, constructor_name:)
+        @raw_bytes = raw_bytes
+        @constructor_id = constructor_id
+        @constructor_name = constructor_name
+      end
+
+      def self.deserialize(bytes)
+        constructor = bytes[0, 4].unpack1('L<')
+        name = ConstructorNames::NAMES[constructor] || "0x#{constructor.to_s(16)}"
+        new(raw_bytes: bytes, constructor_id: constructor, constructor_name: name)
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module MTProto
         @encrypted_data = encrypted_data
       end
 
-      def body
+      def serialize
         result = u32_b(Constructors::REQ_DH_PARAMS)
         result += @nonce.bytes
         result += @server_nonce.bytes

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

@@ -13,7 +13,7 @@ module MTProto
         @nonce = nonce
       end
 
-      def body
+      def serialize
         u32_b(Constructors::REQ_PQ_MULTI) + @nonce.bytes
       end
     end

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

@@ -7,7 +7,7 @@ module MTProto
 
       attr_reader :nonce, :server_nonce, :pq, :fingerprints
 
-      def self.parse(message)
+      def self.deserialize(message)
         data = message.body
         constructor = b_u32(data[0, 4])
         raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == Constructors::RES_PQ

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ResolveUsername
+      include Binary
+
+      CONSTRUCTOR = 0x725afbbc
+
+      def initialize(username:)
+        @username = username
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(0) # flags
+        result += serialize_tl_string(@username)
+        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/save_file_part.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SaveFilePart
+      include Binary
+
+      def initialize(file_id:, file_part:, bytes:)
+        @file_id = file_id
+        @file_part = file_part
+        @bytes = bytes
+      end
+
+      def serialize
+        u32_b(Constructors::UPLOAD_SAVE_FILE_PART) +
+          u64_b(@file_id) +
+          u32_b(@file_part) +
+          serialize_tl_bytes(@bytes)
+      end
+
+      private
+
+      def serialize_tl_bytes(bytes)
+        bytes = bytes.bytes if bytes.is_a?(String)
+        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/send_code.rb

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

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    class SendMedia
+      include Binary
+
+      def initialize(peer:, media:, message: '', random_id: nil)
+        @peer = peer
+        @media = media
+        @message = message
+        @random_id = random_id || SecureRandom.random_number(2**63)
+      end
+
+      def serialize
+        result = u32_b(Constructors::MESSAGES_SEND_MEDIA)
+        result += u32_b(0) # flags
+        result += serialize_input_peer
+        result += serialize_input_media
+        result += serialize_tl_string(@message)
+        result += u64_b(@random_id)
+        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_input_media
+        case @media[:type]
+        when :uploaded_photo
+          serialize_input_media_uploaded_photo(@media[:file])
+        else
+          raise "Unknown media type: #{@media[:type]}"
+        end
+      end
+
+      def serialize_input_media_uploaded_photo(file)
+        result = u32_b(Constructors::INPUT_MEDIA_UPLOADED_PHOTO)
+        result += u32_b(0) # flags
+        result += serialize_input_file(file)
+        result
+      end
+
+      def serialize_input_file(file)
+        u32_b(Constructors::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/objects/send_message.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    class SendMessage
+      include Binary
+
+      INPUT_REPLY_TO_MESSAGE = 0x869fbe10
+
+      def initialize(peer:, message:, random_id: nil, reply_to: nil)
+        @peer = peer
+        @message = message
+        @random_id = random_id || SecureRandom.random_number(2**63)
+        @reply_to = reply_to
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @reply_to
+
+        result = u32_b(Constructors::MESSAGES_SEND_MESSAGE)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += serialize_reply_to if @reply_to
+        result += serialize_tl_string(@message)
+        result += u64_b(@random_id)
+        result
+      end
+
+      private
+
+      def serialize_reply_to
+        u32_b(INPUT_REPLY_TO_MESSAGE) + u32_b(0) + u32_b(@reply_to)
+      end
+
+      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/send_reaction.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SendReaction
+      include Binary
+
+      CONSTRUCTOR = 0xd30d78d4
+      REACTION_EMOJI = 0x1b2286b8
+
+      # emoticons: array of emoji strings (a single-element array is the common case);
+      # an empty array clears the reaction.
+      def initialize(peer:, msg_id:, emoticons: [])
+        @peer = peer
+        @msg_id = msg_id
+        @emoticons = emoticons
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) unless @emoticons.empty? # reaction field present
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += u32_b(@msg_id)
+        unless @emoticons.empty?
+          result += u32_b(Constructors::VECTOR) + u32_b(@emoticons.length)
+          @emoticons.each { |e| result += u32_b(REACTION_EMOJI) + serialize_tl_string(e) }
+        end
+        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.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