mtproto 0.0.14 → 0.0.17

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'bot_command_scope'
+
+module MTProto
+  module TL
+    # bots.getBotCommands — fetch the bot's commands for a given scope/language.
+    # Returns Vector<BotCommand>. Result parsing belongs to a later layer; this
+    # object only builds the request.
+    class GetBotCommands
+      include Binary
+
+      CONSTRUCTOR = 0xe34c0dd6
+
+      # scope: BotCommandScope hash (see BotCommandScope); defaults to default scope.
+      def initialize(scope: { type: :default }, lang_code: '')
+        @scope = scope
+        @lang_code = lang_code
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += BotCommandScope.serialize(@scope)
+        result += serialize_tl_string(@lang_code)
+        result
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.to_s.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/get_file.rb

@@ -7,10 +7,18 @@ module MTProto
 
       CONSTRUCTOR = 0xbe5335be
       INPUT_PHOTO_FILE_LOCATION = 0x40181ffe
+      INPUT_DOCUMENT_FILE_LOCATION = 0xbad07584
+
+      LOCATION_CONSTRUCTORS = {
+        photo: INPUT_PHOTO_FILE_LOCATION,
+        document: INPUT_DOCUMENT_FILE_LOCATION
+      }.freeze
 
       # location: { id:, access_hash:, file_reference: (binary String), thumb_size: (String) }
-      def initialize(location:, offset: 0, limit: 1024 * 1024)
+      # type: :photo for photos, :document for documents/voice/video/audio.
+      def initialize(location:, type: :photo, offset: 0, limit: 1024 * 1024)
         @location = location
+        @type = type
         @offset = offset
         @limit = limit
       end
@@ -27,7 +35,7 @@ module MTProto
       private
 
       def serialize_location
-        u32_b(INPUT_PHOTO_FILE_LOCATION) +
+        u32_b(LOCATION_CONSTRUCTORS.fetch(@type)) +
           u64_b(@location[:id]) +
           u64_b(@location[:access_hash]) +
           serialize_tl_bytes(@location[:file_reference]) +

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ImportAuthorization
+      include Binary
+
+      def initialize(id:, bytes:)
+        @id = id
+        @bytes = bytes
+      end
+
+      def serialize
+        u32_b(Constructors::AUTH_IMPORT_AUTHORIZATION) +
+          u64_b(@id) +
+          serialize_tl_bytes(@bytes)
+      end
+
+      private
+
+      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/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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class KeyboardButtonCallback
+      include Binary
+
+      CONSTRUCTOR = 0xe62bc960
+
+      # data: raw callback payload bytes echoed back to the bot on press.
+      def initialize(text:, data:, requires_password: false)
+        @text = text
+        @data = data
+        @requires_password = requires_password
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @requires_password
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@text)
+        result += serialize_tl_bytes(@data)
+        result
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        serialize_tl_bytes(str.to_s.encode('UTF-8').b)
+      end
+
+      def serialize_tl_bytes(bytes_str)
+        bytes = 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/message.rb

@@ -1,37 +1,113 @@
 # frozen_string_literal: true
 
+require_relative '../reader'
+
 module MTProto
   module TL
+    # The high-level chat-message TL structure `message#7600b9d3` (text/media/
+    # fwd_from/reply/sender/...). Owns the field walk for that one constructor; the
+    # low-level TL reads it needs (peer/string/bytes/media/document, plus the
+    # shared schema) live in Reader and are reused here.
+    #
+    # Reading is decoupled from alignment: `.deserialize` only READS the fields we
+    # surface and returns a Message (or nil for a non-`message` constructor — e.g.
+    # messageService/messageEmpty). Advancing past the whole object is the caller's
+    # job via `Schema#skip`, so any unmodelled tail never drops the message. This is
+    # the single parser for all three inbound paths (live `Updates` push,
+    # `updates.getDifference`, and `messages.getHistory`).
     class Message
-      attr_reader :auth_key_id, :msg_id, :body
+      MESSAGE = Constructors::MESSAGE
+      MESSAGE_FWD_HEADER = 0x4e4df4bb
 
-      def initialize(auth_key_id:, msg_id:, body:)
-        @auth_key_id = auth_key_id
-        @msg_id = msg_id
-        @body = body
-      end
+      FIELDS = %i[id date message peer_type peer_id from_type from_id out media
+                  document photo is_reply reply_to_msg_id fwd_from_type fwd_from_id].freeze
+
+      attr_reader(*FIELDS)
+
+      # `text` is the message body; a get_history-friendly alias for `message`.
+      alias text message
 
-      def serialize
-        auth_key_id_bytes = [@auth_key_id].pack('Q<')
-        msg_id_bytes = [@msg_id].pack('Q<')
-        body_length = [@body.bytesize].pack('L<')
+      def initialize(attrs)
+        FIELDS.each { |f| instance_variable_set("@#{f}", attrs[f]) }
+      end
 
-        auth_key_id_bytes + msg_id_bytes + body_length + @body
+      # The legacy hash shape the Updates / UpdatesDifference consumers expect.
+      def to_h
+        FIELDS.each_with_object({}) { |f, h| h[f] = public_send(f) }
       end
 
-      def self.deserialize(data)
-        if data.bytesize < 20
-          raise(ArgumentError,
-            'Invalid MTProto message: expected at least 20 bytes, ' \
-            "got #{data.bytesize} bytes (hex: #{data.unpack1('H*')})")
+      class << self
+        def deserialize(data, offset, constructor)
+          return unless constructor == MESSAGE
+
+          offset += 4 # constructor
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          flags2 = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('l<')
+          offset += 4
+
+          from_type = from_id = nil
+          from_type, from_id, offset = x.parse_peer(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
+          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          _, offset = x.read_tl_string(data, offset) if flags2.anybits?(1 << 12) # from_rank (layer 227)
+          peer_type, peer_id, offset = x.parse_peer(data, offset)
+          offset = x.schema.skip(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
+          fwd_from_type = fwd_from_id = nil
+          if flags.anybits?(1 << 2) # fwd_from
+            fwd_from_type, fwd_from_id = parse_fwd_origin(data, offset)
+            offset = x.schema.skip(data, offset)
+          end
+          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
+          offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
+          offset = x.schema.skip(data, offset) if flags2.anybits?(1 << 19) # guestchat_via_from (layer 227, Peer)
+
+          is_reply = false
+          reply_to_msg_id = nil
+          if flags.anybits?(1 << 3) # reply_to
+            reply_to_msg_id, is_reply = x.parse_reply_to(data, offset)
+            offset = x.schema.skip(data, offset)
+          end
+
+          date = data[offset, 4].unpack1('L<')
+          offset += 4
+          message_text, offset = x.read_tl_string(data, offset)
+          has_media = flags.anybits?(1 << 9)
+          media = has_media ? x.parse_media(data, offset) : nil
+          document = has_media ? x.parse_document(data, offset) : nil
+          photo = has_media ? x.parse_photo(data, offset) : nil
+
+          new(id: id, date: date, message: message_text, peer_type: peer_type, peer_id: peer_id,
+            from_type: from_type, from_id: from_id, out: flags.anybits?(1 << 1),
+            media: media, document: document, photo: photo, is_reply: is_reply,
+            reply_to_msg_id: reply_to_msg_id, fwd_from_type: fwd_from_type, fwd_from_id: fwd_from_id)
         end
 
-        auth_key_id = data[0, 8].unpack1('Q<')
-        msg_id = data[8, 8].unpack1('Q<')
-        body_length = data[16, 4].unpack1('L<')
-        body = data[20, body_length]
+        private
+
+        # The low-level TL primitives, shared from Reader.
+        def x
+          Reader
+        end
 
-        new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
+        # messageFwdHeader#4e4df4bb flags:# imported:flags.7?true from_id:flags.0?Peer
+        # ... — from_id is the forward origin (a peerChannel for a forwarded channel
+        # post). imported (flags.7) is a flag-only bool, so from_id sits right after
+        # the flags. => [type, id] or [nil, nil].
+        def parse_fwd_origin(data, offset)
+          return [nil, nil] unless data[offset, 4].unpack1('L<') == MESSAGE_FWD_HEADER
+
+          io = offset + 4
+          flags = data[io, 4].unpack1('L<')
+          io += 4
+          return [nil, nil] unless flags.anybits?(1 << 0) # from_id present
+
+          type, id, = x.parse_peer(data, io)
+          [type, id]
+        rescue StandardError
+          [nil, nil]
+        end
       end
     end
   end

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

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
 require_relative '../schema'
+require_relative 'message'
 
 module MTProto
   module TL
+    # A messages.messages / messagesSlice / channelMessages container (e.g. the
+    # messages.getHistory reply). Its messages are TL::Message instances.
     class Messages
-      Message = Struct.new(:id, :from_id, :date, :text, keyword_init: true)
-
-      MESSAGES_MESSAGES = 0x8c718e87
-      MESSAGES_SLICE = 0x762b263d
+      MESSAGES_MESSAGES = 0x1d73e7ea
+      MESSAGES_SLICE = 0x5f206716
       MESSAGES_CHANNEL = 0xc776ba4e
 
-      MESSAGE = Constructors::MESSAGE
-      MESSAGE_SERVICE = 0x7a800e0a
-      MESSAGE_EMPTY = 0x90a6ca84
-
       VALID_CONSTRUCTORS = [MESSAGES_MESSAGES, MESSAGES_SLICE, MESSAGES_CHANNEL].freeze
 
       attr_reader :messages, :count
@@ -86,76 +83,12 @@ module MTProto
           messages = []
           count.times do
             constructor = data[offset, 4].unpack1('L<')
-
-            if constructor == MESSAGE
-              msg, = parse_message(data, offset)
-              messages << msg if msg
-            end
-
+            msg = Message.deserialize(data, offset, constructor)
+            messages << msg if msg
             offset = schema.skip(data, offset)
           end
           [messages, offset]
         end
-
-        # message#9815cec8 flags:# flags2:# id:int
-        #   from_id:flags.8?Peer ... date:int message:string ...
-        def parse_message(data, offset)
-          offset += 4 # constructor
-          flags = data[offset, 4].unpack1('L<')
-          offset += 4
-          flags2 = data[offset, 4].unpack1('L<')
-          offset += 4
-          id = data[offset, 4].unpack1('l<')
-          offset += 4
-
-          from_id = nil
-          _, from_id, offset = parse_peer(data, offset) if flags.anybits?(1 << 8)
-          offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
-          _, _, offset = parse_peer(data, offset) # peer_id (skip)
-          _, _, offset = parse_peer(data, offset) if flags.anybits?(1 << 28) # saved_peer_id
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 2) # fwd_from
-          offset += 8 if flags.anybits?(1 << 11) # via_bot_id
-          offset += 8 if flags2.anybits?(1 << 0) # via_business_bot_id
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
-
-          date = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          text, offset = read_tl_string(data, offset)
-
-          msg = Message.new(id: id, from_id: from_id, date: date, text: text)
-          [msg, offset]
-        end
-
-        def parse_peer(data, offset)
-          constructor = data[offset, 4].unpack1('L<')
-          offset += 4
-          case constructor
-          when Constructors::PEER_USER
-            [:user, data[offset, 8].unpack1('Q<'), offset + 8]
-          when Constructors::PEER_CHAT
-            [:chat, data[offset, 8].unpack1('Q<'), offset + 8]
-          when Constructors::PEER_CHANNEL
-            [:channel, data[offset, 8].unpack1('Q<'), offset + 8]
-          else
-            raise "Unknown peer constructor: 0x#{constructor.to_s(16)}"
-          end
-        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
       end
     end
   end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReplyInlineMarkup
+      include Binary
+
+      CONSTRUCTOR = 0x48a30254
+      KEYBOARD_BUTTON_ROW = 0x77608b83
+
+      # rows: array of rows; each row is an array of button objects (each responds to #serialize).
+      def initialize(rows:)
+        @rows = rows
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(@rows.size)
+        @rows.each do |row|
+          result += u32_b(KEYBOARD_BUTTON_ROW)
+          result += u32_b(Constructors::VECTOR)
+          result += u32_b(row.size)
+          row.each { |button| result += button.serialize }
+        end
+        result
+      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/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/reset_bot_commands.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'bot_command_scope'
+
+module MTProto
+  module TL
+    # bots.resetBotCommands — clear the bot's commands for a given scope/language.
+    # Returns Bool.
+    class ResetBotCommands
+      include Binary
+
+      CONSTRUCTOR = 0x3d8de0f9
+
+      # scope: BotCommandScope hash (see BotCommandScope); defaults to default scope.
+      def initialize(scope: { type: :default }, lang_code: '')
+        @scope = scope
+        @lang_code = lang_code
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += BotCommandScope.serialize(@scope)
+        result += serialize_tl_string(@lang_code)
+        result
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.to_s.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