mtproto 0.0.14 → 0.0.17

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

@@ -7,17 +7,30 @@ module MTProto
     class SendMedia
       include Binary
 
-      def initialize(peer:, media:, message: '', random_id: nil)
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
+      INPUT_MEDIA_PHOTO = 0xe3af4434
+      INPUT_MEDIA_DOCUMENT = 0xa8763ab5
+      INPUT_PHOTO = 0x3bb3b94a
+      INPUT_DOCUMENT = 0x1abfb575
+
+      def initialize(peer:, media:, message: '', random_id: nil, reply_to: nil, silent: false)
         @peer = peer
         @media = media
         @message = message
         @random_id = random_id || SecureRandom.random_number(2**63)
+        @reply_to = reply_to
+        @silent = silent
       end
 
       def serialize
+        flags = 0
+        flags |= (1 << 0) if @reply_to
+        flags |= (1 << 5) if @silent
+
         result = u32_b(Constructors::MESSAGES_SEND_MEDIA)
-        result += u32_b(0) # flags
+        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)
@@ -26,6 +39,10 @@ module MTProto
 
       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
@@ -45,11 +62,27 @@ module MTProto
         case @media[:type]
         when :uploaded_photo
           serialize_input_media_uploaded_photo(@media[:file])
+        when :uploaded_document
+          serialize_input_media_uploaded_document(@media)
+        when :photo
+          serialize_existing_media(INPUT_MEDIA_PHOTO, INPUT_PHOTO, @media)
+        when :document
+          serialize_existing_media(INPUT_MEDIA_DOCUMENT, INPUT_DOCUMENT, @media)
         else
           raise "Unknown media type: #{@media[:type]}"
         end
       end
 
+      # Re-send media that already lives on Telegram, by reference — inputMediaPhoto/
+      # inputMediaDocument (flags=0) wrapping inputPhoto/inputDocument(id, access_hash,
+      # file_reference). Used to re-post a guest-mention's photo/video, where the bot
+      # cannot forward from a chat it is not a member of.
+      def serialize_existing_media(media_ctor, input_ctor, media)
+        u32_b(media_ctor) + u32_b(0) +
+          u32_b(input_ctor) + u64_b(media[:id]) + u64_b(media[:access_hash]) +
+          serialize_bytes(media[:file_reference])
+      end
+
       def serialize_input_media_uploaded_photo(file)
         result = u32_b(Constructors::INPUT_MEDIA_UPLOADED_PHOTO)
         result += u32_b(0) # flags
@@ -57,6 +90,48 @@ module MTProto
         result
       end
 
+      # inputMediaUploadedDocument with flags=0 (no thumb/stickers/ttl/video
+      # fields): file, mime_type, then the document-attributes vector. A generic
+      # file carries documentAttributeFilename; audio adds documentAttributeAudio.
+      def serialize_input_media_uploaded_document(media)
+        u32_b(Constructors::INPUT_MEDIA_UPLOADED_DOCUMENT) +
+          u32_b(0) +
+          serialize_input_file(media[:file]) +
+          serialize_tl_string(media[:mime_type].to_s) +
+          serialize_document_attributes(media[:attributes] || [])
+      end
+
+      def serialize_document_attributes(attributes)
+        result = u32_b(Constructors::VECTOR) + u32_b(attributes.length)
+        attributes.each { |attribute| result += serialize_document_attribute(attribute) }
+        result
+      end
+
+      def serialize_document_attribute(attribute)
+        case attribute[:type]
+        when :filename
+          u32_b(Constructors::DOCUMENT_ATTRIBUTE_FILENAME) +
+            serialize_tl_string(attribute[:file_name].to_s)
+        when :audio
+          serialize_document_attribute_audio(attribute)
+        else
+          raise "Unknown document attribute: #{attribute[:type]}"
+        end
+      end
+
+      # documentAttributeAudio: voice=flags.10, title=flags.0, performer=flags.1;
+      # title is written before performer on the wire.
+      def serialize_document_attribute_audio(attribute)
+        flags = 0
+        flags |= (1 << 0) if attribute[:title]
+        flags |= (1 << 1) if attribute[:performer]
+        flags |= (1 << 10) if attribute[:voice]
+        result = u32_b(Constructors::DOCUMENT_ATTRIBUTE_AUDIO) + u32_b(flags) + u32_b(attribute[:duration].to_i)
+        result += serialize_tl_string(attribute[:title]) if attribute[:title]
+        result += serialize_tl_string(attribute[:performer]) if attribute[:performer]
+        result
+      end
+
       def serialize_input_file(file)
         u32_b(Constructors::INPUT_FILE) +
           u64_b(file[:id]) +
@@ -66,9 +141,17 @@ module MTProto
       end
 
       def serialize_tl_string(str)
-        bytes = str.encode('UTF-8').bytes
-        length = bytes.length
+        serialize_byte_array(str.encode('UTF-8').bytes)
+      end
 
+      # TL bytes for a raw binary string (e.g. a file_reference) — NOT re-encoded as
+      # UTF-8, which would corrupt arbitrary bytes.
+      def serialize_bytes(raw)
+        serialize_byte_array(raw.to_s.b.bytes)
+      end
+
+      def serialize_byte_array(bytes)
+        length = bytes.length
         if length <= 253
           [length] + bytes + padding(length + 1)
         else

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

@@ -7,18 +7,22 @@ module MTProto
     class SendMessage
       include Binary
 
-      INPUT_REPLY_TO_MESSAGE = 0x869fbe10
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
 
-      def initialize(peer:, message:, random_id: nil, reply_to: nil)
+      def initialize(peer:, message:, random_id: nil, reply_to: nil, reply_markup: nil, silent: false)
         @peer = peer
         @message = message
         @random_id = random_id || SecureRandom.random_number(2**63)
         @reply_to = reply_to
+        @reply_markup = reply_markup
+        @silent = silent
       end
 
       def serialize
         flags = 0
         flags |= (1 << 0) if @reply_to
+        flags |= (1 << 2) if @reply_markup
+        flags |= (1 << 5) if @silent
 
         result = u32_b(Constructors::MESSAGES_SEND_MESSAGE)
         result += u32_b(flags)
@@ -26,6 +30,7 @@ module MTProto
         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
 

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # A SendMessageAction — the payload of messages.setTyping. Every variant is
+    # just its own constructor id; the upload/import variants additionally carry
+    # a progress:int (0-100). One class covers them all.
+    class SendMessageAction
+      include Binary
+
+      CONSTRUCTORS = {
+        typing: 0x16bf744e,
+        cancel: 0xfd5ec8f5,
+        record_audio: 0xd52f73f7,
+        upload_audio: 0xf351d7ab,
+        record_video: 0xa187d66f,
+        upload_video: 0xe9763aec,
+        record_round: 0x88f27fbc,
+        upload_round: 0x243e1c66,
+        upload_photo: 0xd1d34a26,
+        upload_document: 0xaa0cd9e4,
+        geo_location: 0x176f8ba1,
+        choose_contact: 0x628cbc6f,
+        choose_sticker: 0xb05ac6b1,
+        game_play: 0xdd6a8f48,
+        history_import: 0xdbda9246
+      }.freeze
+
+      WITH_PROGRESS = %i[upload_audio upload_video upload_round upload_photo upload_document history_import].freeze
+
+      def self.types
+        CONSTRUCTORS.keys
+      end
+
+      def initialize(type, progress: 0)
+        @type = type
+        @progress = progress
+      end
+
+      def serialize
+        id = CONSTRUCTORS.fetch(@type) { raise ArgumentError, "unknown SendMessageAction: #{@type}" }
+        result = u32_b(id)
+        result += u32_b(@progress) if WITH_PROGRESS.include?(@type)
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.setBotCallbackAnswer — the bot's reaction to a press. With no
+    # message it just dismisses the button's spinner; with a message it shows a
+    # toast (alert=false) or a modal alert (alert=true).
+    class SetBotCallbackAnswer
+      include Binary
+
+      CONSTRUCTOR = 0xd58f130a
+
+      def initialize(query_id:, message: nil, alert: false, url: nil, cache_time: 0)
+        @query_id = query_id
+        @message = message
+        @alert = alert
+        @url = url
+        @cache_time = cache_time
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @message
+        flags |= (1 << 1) if @alert
+        flags |= (1 << 2) if @url
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += u64_b(@query_id)
+        result += serialize_tl_string(@message) if @message
+        result += serialize_tl_string(@url) if @url
+        result += u32_b(@cache_time)
+        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/set_bot_commands.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'bot_command_scope'
+
+module MTProto
+  module TL
+    class SetBotCommands
+      include Binary
+
+      CONSTRUCTOR = 0x0517165a
+      BOT_COMMAND = 0xc27ac8c7
+
+      # commands: array of { command:, description: }
+      # scope:    BotCommandScope hash (see BotCommandScope); defaults to default scope.
+      def initialize(commands:, scope: { type: :default }, lang_code: '')
+        @commands = commands
+        @scope = scope
+        @lang_code = lang_code
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += BotCommandScope.serialize(@scope)
+        result += serialize_tl_string(@lang_code)
+        result += u32_b(Constructors::VECTOR)
+        result += u32_b(@commands.size)
+        @commands.each do |cmd|
+          result += u32_b(BOT_COMMAND)
+          result += serialize_tl_string(cmd[:command])
+          result += serialize_tl_string(cmd[:description])
+        end
+        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/set_bot_guest_chat_result.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module MTProto
+  module TL
+    # messages.setBotGuestChatResult#b8f106e3 query_id:long result:InputBotInlineResult
+    #   = InputBotInlineMessageID
+    # How a guest-mode bot answers an updateBotGuestChatQuery: the reply text is wrapped
+    # in inputBotInlineResult(type "article") -> inputBotInlineMessageText, and the server
+    # posts that message into the guest chat. Text-only for now (no media / buttons).
+    class SetBotGuestChatResult
+      include Binary
+
+      CONSTRUCTOR = 0xb8f106e3
+      INPUT_BOT_INLINE_RESULT = 0x88bf9319         # inputBotInlineResult
+      INPUT_BOT_INLINE_MESSAGE_TEXT = 0x3dcd7a87   # inputBotInlineMessageText
+
+      def initialize(query_id:, message:, result_id: nil, result_type: 'article', result_title: nil)
+        @query_id = query_id
+        @message = message
+        @result_id = result_id || SecureRandom.hex(8)
+        @result_type = result_type
+        # The "article" result type requires a non-empty title (the server rejects an
+        # empty one with ARTICLE_TITLE_EMPTY); the actual reply shown is send_message.
+        @result_title = result_title || message_title
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u64_b(@query_id)
+        result += serialize_result
+        result
+      end
+
+      private
+
+      # inputBotInlineResult#88bf9319 flags:# id:string type:string
+      #   title:flags.1?string description:flags.2? ... send_message:InputBotInlineMessage
+      # flags = 1<<1: id/type + the required title, then send_message.
+      def serialize_result
+        result = u32_b(INPUT_BOT_INLINE_RESULT)
+        result += u32_b(1 << 1) # title present
+        result += serialize_tl_string(@result_id)
+        result += serialize_tl_string(@result_type)
+        result += serialize_tl_string(@result_title)
+        result += serialize_send_message
+        result
+      end
+
+      def message_title
+        title = @message.to_s.strip
+        title = 'Ответ' if title.empty?
+        title[0, 64]
+      end
+
+      # inputBotInlineMessageText#3dcd7a87 flags:# no_webpage:flags.0?true
+      #   invert_media:flags.3?true message:string entities:flags.1? reply_markup:flags.2?
+      # flags = 0: a plain text message.
+      def serialize_send_message
+        result = u32_b(INPUT_BOT_INLINE_MESSAGE_TEXT)
+        result += u32_b(0)
+        result += serialize_tl_string(@message)
+        result
+      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/set_bot_info.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SetBotInfo
+      include Binary
+
+      CONSTRUCTOR = 0x10cf3123
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot: { id:, access_hash: } or { type: :self } (nil = the calling bot)
+      def initialize(bot: nil, lang_code: '', name: nil, about: nil, description: nil)
+        @bot = bot
+        @lang_code = lang_code
+        @name = name
+        @about = about
+        @description = description
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 2) if @bot
+        flags |= (1 << 3) if @name
+        flags |= (1 << 0) if @about
+        flags |= (1 << 1) if @description
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot) if @bot
+        result += serialize_tl_string(@lang_code)
+        result += serialize_tl_string(@name) if @name
+        result += serialize_tl_string(@about) if @about
+        result += serialize_tl_string(@description) if @description
+        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
+
+      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/set_typing.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.setTyping — show a chat action ("typing…", "sending photo…", …)
+    # in the target peer. action is a SendMessageAction; top_msg_id targets a
+    # forum topic / thread. Returns Bool.
+    class SetTyping
+      include Binary
+
+      CONSTRUCTOR = 0x58943ee2
+
+      def initialize(peer:, action:, top_msg_id: nil)
+        @peer = peer
+        @action = action
+        @top_msg_id = top_msg_id
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @top_msg_id
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += u32_b(@top_msg_id) if @top_msg_id
+        result += @action.serialize
+        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
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # account.updateStatus — mark the session online or offline. offline:false
+    # is what a foreground client sends to go online (and to start receiving
+    # transient updates like updateUserTyping). Returns Bool.
+    class UpdateStatus
+      include Binary
+
+      CONSTRUCTOR = 0x6628562c
+      BOOL_TRUE = 0x997275b5
+      BOOL_FALSE = 0xbc799737
+
+      def initialize(offline:)
+        @offline = offline
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) + u32_b(@offline ? BOOL_TRUE : BOOL_FALSE)
+      end
+    end
+  end
+end