mtproto 0.0.13 → 0.0.15

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.getMessages#63c66506 id:Vector<InputMessage> — fetch messages by id
+    # from a basic group or private chat (the non-channel counterpart of
+    # channels.getMessages). Returns messages.messages / messagesSlice.
+    class MessagesGetMessages
+      include Binary
+
+      CONSTRUCTOR = 0x63c66506
+      INPUT_MESSAGE_ID = 0xa676a322
+
+      def initialize(ids:)
+        @ids = ids
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
+        @ids.each { |id| result += u32_b(INPUT_MESSAGE_ID) + u32_b(id) }
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReplyKeyboardMarkup
+      include Binary
+
+      CONSTRUCTOR = 0x85dd99d1
+      KEYBOARD_BUTTON_ROW = 0x77608b83
+
+      # buttons: a single row of button objects (each responds to #serialize)
+      def initialize(buttons:, resize: true, single_use: false)
+        @buttons = buttons
+        @resize = resize
+        @single_use = single_use
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @resize
+        flags |= (1 << 1) if @single_use
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(1)
+        result += u32_b(KEYBOARD_BUTTON_ROW)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(@buttons.size)
+        @buttons.each { |button| result += button.serialize }
+        result
+      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/request_peer_type_create_bot.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class RequestPeerTypeCreateBot
+      include Binary
+
+      CONSTRUCTOR = 0x3e81e078
+
+      def initialize(bot_managed: true, suggested_name: nil, suggested_username: nil)
+        @bot_managed = bot_managed
+        @suggested_name = suggested_name
+        @suggested_username = suggested_username
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @bot_managed
+        flags |= (1 << 1) if @suggested_name
+        flags |= (1 << 2) if @suggested_username
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@suggested_name) if @suggested_name
+        result += serialize_tl_string(@suggested_username) if @suggested_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/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_bot_requested_peer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SendBotRequestedPeer
+      include Binary
+
+      CONSTRUCTOR = 0x6c5cf2a7
+
+      # peer / requested_peers entries: { type:, id:, access_hash: } or { type: :self }
+      def initialize(peer:, button_id:, msg_id: nil, requested_peers: [])
+        @peer = peer
+        @button_id = button_id
+        @msg_id = msg_id
+        @requested_peers = requested_peers
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @msg_id
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_peer(@peer)
+        result += u32_b(@msg_id) if @msg_id
+        result += u32_b(@button_id)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(@requested_peers.size)
+        @requested_peers.each { |peer| result += serialize_input_peer(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/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,96 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    class SendMedia
+      include Binary
+
+      INPUT_REPLY_TO_MESSAGE = 0x869fbe10
+
+      def initialize(peer:, media:, message: '', random_id: nil, reply_to: nil)
+        @peer = peer
+        @media = media
+        @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_MEDIA)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += serialize_reply_to if @reply_to
+        result += serialize_input_media
+        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_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,73 @@
+# 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, reply_markup: nil)
+        @peer = peer
+        @message = message
+        @random_id = random_id || SecureRandom.random_number(2**63)
+        @reply_to = reply_to
+        @reply_markup = reply_markup
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @reply_to
+        flags |= (1 << 2) if @reply_markup
+
+        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 += @reply_markup.serialize if @reply_markup
+        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

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

@@ -13,7 +13,7 @@ module MTProto
         @timeout = timeout
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
         raise UnexpectedConstructorError, constructor unless constructor == Constructors::AUTH_SENT_CODE
 

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

@@ -5,7 +5,7 @@ module MTProto
     class ServerDHInnerData
       attr_reader :nonce, :server_nonce, :g, :dh_prime, :g_a, :server_time
 
-      def self.parse(bytes)
+      def self.deserialize(bytes)
         constructor = bytes[0, 4].unpack1('L<')
         unless constructor == Constructors::SERVER_DH_INNER_DATA
           raise "Unexpected constructor: 0x#{constructor.to_s(16)}"

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

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