mtproto 0.0.15 → 0.0.17

data/lib/mtproto/tl/constructors.rb

@@ -56,6 +56,9 @@ module MTProto
       AUTH_SIGN_IN = 0x8d52a951
       AUTH_AUTHORIZATION = 0x2ea2c0d4
       AUTH_AUTHORIZATION_SIGN_UP_REQUIRED = 0x44747e9a
+      AUTH_EXPORT_AUTHORIZATION = 0xe5bfffcd
+      AUTH_EXPORTED_AUTHORIZATION = 0xb434e2b8
+      AUTH_IMPORT_AUTHORIZATION = 0xa57a7dad
       AUTH_CHECK_PASSWORD = 0xd18b4d16
       AUTH_EXPORT_LOGIN_TOKEN = 0xb7e085fe
       AUTH_IMPORT_LOGIN_TOKEN = 0x95ac5ce4
@@ -70,7 +73,7 @@ module MTProto
 
       # Users
       USERS_GET_USERS = 0x0d91a548
-      USER = 0x020b1422
+      USER = 0x31774388
 
       # Contacts
       CONTACTS_GET_CONTACTS = 0x5dd69e12
@@ -81,25 +84,30 @@ module MTProto
       # Messages
       MESSAGES_GET_DIALOGS = 0xa0f4cb4f
       MESSAGES_GET_HISTORY = 0x4423e6c5
-      MESSAGES_SEND_MESSAGE = 0xfe05dc9a
-      MESSAGES_SEND_MEDIA = 0xac55d9c1
-      MESSAGES_EDIT_MESSAGE = 0xdfd14005
+      MESSAGES_SEND_MESSAGE = 0xfef48f62
+      MESSAGES_SEND_MEDIA = 0x0330e77f
+      MESSAGES_EDIT_MESSAGE = 0xb106e66c
       MESSAGES_DELETE_MESSAGES = 0xe58e95d2
 
       # Upload + media
       UPLOAD_SAVE_FILE_PART = 0xb304a621
       INPUT_FILE = 0xf52ff27f
-      INPUT_MEDIA_UPLOADED_PHOTO = 0x1e287d04
+      INPUT_MEDIA_UPLOADED_PHOTO = 0x7d8375da
+      INPUT_MEDIA_UPLOADED_DOCUMENT = 0x037c9330
+      DOCUMENT_ATTRIBUTE_FILENAME = 0x15590068
+      DOCUMENT_ATTRIBUTE_AUDIO = 0x9852f9c6
       MESSAGES_DIALOGS = 0x15ba6c40
       MESSAGES_DIALOGS_SLICE = 0x71e094f3
-      MESSAGE = 0x9815cec8
-      DIALOG = 0xd58a08c6
+      MESSAGE = 0x7600b9d3
+      DIALOG = 0xfc89f7f3
       CHAT = 0x41cbf256
       CHAT_FORBIDDEN = 0x6592a1a7
-      CHANNEL = 0xfe685355
+      CHANNEL = 0x1c32b11c
       CHANNEL_FORBIDDEN = 0x17d493d5
 
       # Updates
+      UPDATES = 0x74ae4240
+      UPDATES_COMBINED = 0x725b04c3
       UPDATE_NEW_MESSAGE = 0x1f2b0afd
       UPDATE_SHORT = 0x78d4dec1
       UPDATE_SHORT_MESSAGE = 0x313bc7f8

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # Serializes a BotCommandScope — the `scope:` field shared by
+    # bots.setBotCommands / bots.resetBotCommands / bots.getBotCommands.
+    #
+    # scope is a hash:
+    #   { type: :default }
+    #   { type: :users }
+    #   { type: :chats }
+    #   { type: :chat_admins }
+    #   { type: :peer,        peer: <input_peer> }
+    #   { type: :peer_admins, peer: <input_peer> }
+    #   { type: :peer_user,   peer: <input_peer>, user: <input_user> }
+    #
+    # input_peer is the same shape used elsewhere (e.g. SendMessage):
+    #   { type: :self | :user | :chat | :channel, id:, access_hash: }
+    # input_user:
+    #   { type: :self } or { id:, access_hash: }
+    module BotCommandScope
+      extend Binary
+
+      module_function
+
+      DEFAULT     = 0x2f6cb2ab
+      USERS       = 0x3c4f04d8
+      CHATS       = 0x6fe1a881
+      CHAT_ADMINS = 0xb9aa606a
+      PEER        = 0xdb9d897d
+      PEER_ADMINS = 0x3fd863d1
+      PEER_USER   = 0x0a1321f3
+
+      INPUT_USER      = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      def serialize(scope)
+        scope ||= { type: :default }
+        case scope[:type]
+        when :default     then u32_b(DEFAULT)
+        when :users       then u32_b(USERS)
+        when :chats       then u32_b(CHATS)
+        when :chat_admins then u32_b(CHAT_ADMINS)
+        when :peer        then u32_b(PEER) + serialize_input_peer(scope[:peer])
+        when :peer_admins then u32_b(PEER_ADMINS) + serialize_input_peer(scope[:peer])
+        when :peer_user
+          u32_b(PEER_USER) + serialize_input_peer(scope[:peer]) + serialize_input_user(scope[:user])
+        else
+          raise ArgumentError, "Unknown bot command scope: #{scope[:type].inspect}"
+        end
+      end
+
+      def serialize_input_peer(peer)
+        raise ArgumentError, 'scope requires peer:' if peer.nil?
+
+        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 ArgumentError, "Unknown peer type: #{peer[:type].inspect}"
+        end
+      end
+
+      def serialize_input_user(user)
+        raise ArgumentError, 'peer_user scope requires user:' if user.nil?
+
+        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/channels_join_channel.rb

@@ -5,7 +5,7 @@ module MTProto
     class ChannelsJoinChannel
       include Binary
 
-      CONSTRUCTOR = 0x24b524c5
+      CONSTRUCTOR = 0x7f6a1e22
 
       def initialize(channel:)
         @channel = channel

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # channels.updateUsername — assign a public username to a channel/supergroup.
+    # Returns Bool.
+    class ChannelsUpdateUsername
+      include Binary
+
+      CONSTRUCTOR = 0x3514b3de
+
+      def initialize(channel:, username:)
+        @channel = channel
+        @username = username
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(Constructors::INPUT_CHANNEL) + u64_b(@channel[:id]) + u64_b(@channel[:access_hash])
+        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/contacts.rb

@@ -68,7 +68,7 @@ module MTProto
           [contacts, offset]
         end
 
-        # User parsing mirrors TL::Dialogs.parse_user (user#020b1422). Kept private here
+        # User parsing mirrors TL::Dialogs.parse_user (user#31774388). Kept private here
         # so this class can be used without instantiating Dialogs.
         def parse_users_vector(data, offset)
           offset += 4 # vector tag

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

@@ -104,6 +104,7 @@ module MTProto
 
           offset += 4 # unread_mentions_count
           offset += 4 # unread_reactions_count
+          offset += 4 # unread_poll_votes_count (added in layer 227)
 
           offset = schema.skip(data, offset) # notify_settings (PeerNotifySettings)
 
@@ -138,12 +139,12 @@ module MTProto
 
         # --- Messages vector ---
 
-        # message#9815cec8 flags:# flags2:#
+        # message#7600b9d3 flags:# flags2:#
         #   id:int from_id:flags.8?Peer from_boosts_applied:flags.29?int
-        #   peer_id:Peer saved_peer_id:flags.28?Peer
+        #   from_rank:flags2.12?string peer_id:Peer saved_peer_id:flags.28?Peer
         #   fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?long
-        #   via_business_bot_id:flags2.0?long reply_to:flags.3?MessageReplyHeader
-        #   date:int ...
+        #   via_business_bot_id:flags2.0?long guestchat_via_from:flags2.19?Peer
+        #   reply_to:flags.3?MessageReplyHeader date:int ...
         #
         # messageService#2b085862 flags:#
         #   id:int from_id:flags.8?Peer peer_id:Peer
@@ -189,11 +190,13 @@ module MTProto
 
           offset = schema.skip(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
           offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
+          _, offset = read_tl_string(data, offset) if flags2.anybits?(1 << 12) # from_rank (layer 227)
           offset = schema.skip(data, offset) # peer_id (Peer, always present)
           offset = schema.skip(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 flags2.anybits?(1 << 19) # guestchat_via_from (layer 227, Peer)
           offset = schema.skip(data, offset) if flags.anybits?(1 << 3) # reply_to
 
           date = data[offset, 4].unpack1('L<')
@@ -278,7 +281,7 @@ module MTProto
           [Chat.new(id: id, title: title, type: :chat), offset]
         end
 
-        # channel#fe685355 flags:# flags2:#
+        # channel#1c32b11c flags:# flags2:#
         #   id:long access_hash:flags.13?long title:string
         #   username:flags.6?string photo:ChatPhoto date:int
         #   restriction_reason:flags.9?Vector<RestrictionReason>
@@ -320,7 +323,7 @@ module MTProto
           if flags2.anybits?(1 << 0) # usernames Vector<Username>
             offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) }
           end
-          offset += 4 if flags2.anybits?(1 << 4) # stories_max_id
+          offset = schema.skip(data, offset) if flags2.anybits?(1 << 4) # stories_max_id (layer 227: RecentStory)
           offset = schema.skip(data, offset) if flags2.anybits?(1 << 7) # color (PeerColor)
           offset = schema.skip(data, offset) if flags2.anybits?(1 << 8) # profile_color (PeerColor)
           offset = schema.skip(data, offset) if flags2.anybits?(1 << 9) # emoji_status
@@ -373,7 +376,7 @@ module MTProto
 
         USER_EMPTY = 0xd3bc4b7a
 
-        # user#020b1422 flags:# flags2:#
+        # user#31774388 flags:# flags2:#
         #   id:long access_hash:flags.0?long
         #   first_name:flags.1?string last_name:flags.2?string
         #   username:flags.3?string phone:flags.4?string
@@ -418,7 +421,9 @@ module MTProto
           last_name = nil
           last_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 2)
 
-          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 3) # username
+          username = nil
+          username, offset = read_tl_string(data, offset) if flags.anybits?(1 << 3) # username
+
           offset = skip_tl_string(data, offset) if flags.anybits?(1 << 4) # phone
           offset = schema.skip(data, offset) if flags.anybits?(1 << 5) # photo
           offset = schema.skip(data, offset) if flags.anybits?(1 << 6) # status
@@ -430,14 +435,14 @@ module MTProto
           offset = skip_tl_string(data, offset) if flags.anybits?(1 << 22) # lang_code
           offset = schema.skip(data, offset) if flags.anybits?(1 << 30) # emoji_status
           offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) } if flags2.anybits?(1 << 0) # usernames
-          offset += 4 if flags2.anybits?(1 << 5) # stories_max_id
+          offset = schema.skip(data, offset) if flags2.anybits?(1 << 5) # stories_max_id (layer 227: RecentStory)
           offset = schema.skip(data, offset) if flags2.anybits?(1 << 8) # color
           offset = schema.skip(data, offset) if flags2.anybits?(1 << 9) # profile_color
           offset += 4 if flags2.anybits?(1 << 12) # bot_active_users
           offset += 8 if flags2.anybits?(1 << 14) # bot_verification_icon
           offset += 8 if flags2.anybits?(1 << 15) # send_paid_messages_stars
 
-          [{ id: id, first_name: first_name, last_name: last_name, access_hash: access_hash }, offset]
+          [{ id: id, first_name: first_name, last_name: last_name, username: username, access_hash: access_hash }, offset]
         end
 
         # --- TL string ---

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportAuthorization
+      include Binary
+
+      def initialize(dc_id:)
+        @dc_id = dc_id
+      end
+
+      def serialize
+        u32_b(Constructors::AUTH_EXPORT_AUTHORIZATION) + u32_b(@dc_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportedAuthorization
+      attr_reader :id, :bytes
+
+      def initialize(id:, bytes:)
+        @id = id
+        @bytes = bytes
+      end
+
+      def self.deserialize(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == Constructors::AUTH_EXPORTED_AUTHORIZATION
+
+        id = data[4, 8].unpack1('Q<')
+        new(id: id, bytes: read_tl_bytes(data, 12))
+      end
+
+      def self.read_tl_bytes(data, offset)
+        first = data.getbyte(offset)
+        if first == 254
+          len = data.getbyte(offset + 1) | (data.getbyte(offset + 2) << 8) | (data.getbyte(offset + 3) << 16)
+          data[offset + 4, len]
+        else
+          data[offset + 1, first]
+        end
+      end
+    end
+  end
+end

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

@@ -7,19 +7,22 @@ module MTProto
     class ForwardMessages
       include Binary
 
-      CONSTRUCTOR = 0x978928ca
+      CONSTRUCTOR = 0x13704a7c
 
-      def initialize(from_peer:, to_peer:, ids:, random_ids: nil, drop_author: false, drop_media_captions: false)
+      def initialize(from_peer:, to_peer:, ids:, random_ids: nil, drop_author: false, drop_media_captions: false,
+                     silent: 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
+        @silent = silent
       end
 
       def serialize
         flags = 0
+        flags |= (1 << 5) if @silent
         flags |= (1 << 11) if @drop_author
         flags |= (1 << 12) if @drop_media_captions
 

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # messages.getBotCallbackAnswer — the press itself: the user client invokes
+    # this with the button's callback data; the server delivers an
+    # updateBotCallbackQuery to the bot and blocks until the bot answers (or
+    # times out), then returns messages.botCallbackAnswer.
+    class GetBotCallbackAnswer
+      include Binary
+
+      CONSTRUCTOR = 0x9342ca07
+
+      def initialize(peer:, msg_id:, data: nil, game: false)
+        @peer = peer
+        @msg_id = msg_id
+        @data = data
+        @game = game
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @data
+        flags |= (1 << 1) if @game
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_peer
+        result += u32_b(@msg_id)
+        result += serialize_tl_bytes(@data) if @data
+        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_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/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/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