mtproto 0.0.14 → 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/create_bot.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class CreateBot
+      include Binary
+
+      CONSTRUCTOR = 0xe5b17f2b
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # manager: { id:, access_hash: } or { type: :self }
+      def initialize(name:, username:, manager:, via_deeplink: false)
+        @name = name
+        @username = username
+        @manager = manager
+        @via_deeplink = via_deeplink
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @via_deeplink
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@name)
+        result += serialize_tl_string(@username)
+        result += if @manager[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@manager[:id]) + u64_b(@manager[:access_hash] || 0)
+                  end
+        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/dialogs.rb

@@ -51,6 +51,16 @@ module MTProto
         new(dialogs: dialogs, chats: chats, users: users, count: count, message_dates: message_dates)
       end
 
+      # Parse a chats:Vector<Chat> / users:Vector<User> at an arbitrary offset.
+      # Reused by UpdatesDifference — the same vectors appear in updates.difference.
+      def self.chats_at(data, offset)
+        parse_chats_vector(data, offset)
+      end
+
+      def self.users_at(data, offset)
+        parse_users_vector(data, offset)
+      end
+
       class << self
         private
 
@@ -94,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)
 
@@ -128,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
@@ -179,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<')
@@ -268,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>
@@ -310,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
@@ -363,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
@@ -408,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
@@ -420,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/edit_access_settings.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class EditAccessSettings
+      include Binary
+
+      CONSTRUCTOR = 0x31813cd8
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot / add_users entries: { id:, access_hash: } or { type: :self }
+      def initialize(bot:, restricted: false, add_users: [])
+        @bot = bot
+        @restricted = restricted
+        @add_users = add_users
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 0) if @restricted
+        flags |= (1 << 1) unless @add_users.empty?
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot)
+        unless @add_users.empty?
+          result += u32_b(Constructors::VECTOR)
+          result += u32_b(@add_users.size)
+          @add_users.each { |u| result += serialize_input_user(u) }
+        end
+        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
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportBotToken
+      include Binary
+
+      CONSTRUCTOR = 0xbd0d99eb
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+      BOOL_TRUE = 0x997275b5
+      BOOL_FALSE = 0xbc799737
+
+      # bot: { id:, access_hash: } or { type: :self }
+      def initialize(bot:, revoke: false)
+        @bot = bot
+        @revoke = revoke
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += if @bot[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@bot[:id]) + u64_b(@bot[:access_hash] || 0)
+                  end
+        result += u32_b(@revoke ? BOOL_TRUE : BOOL_FALSE)
+        result
+      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/exported_bot_token.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportedBotToken
+      CONSTRUCTOR = 0x3c60b621
+
+      attr_reader :token
+
+      def initialize(token:)
+        @token = token
+      end
+
+      def self.deserialize(bytes)
+        body = bytes[4..]
+        first = body.getbyte(0)
+        token = if first == 254
+                  len = body.getbyte(1) | (body.getbyte(2) << 8) | (body.getbyte(3) << 16)
+                  body[4, len]
+                else
+                  body[1, first]
+                end
+        new(token: token.force_encoding('UTF-8'))
+      end
+    end
+  end
+end

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

@@ -7,18 +7,27 @@ module MTProto
     class ForwardMessages
       include Binary
 
-      CONSTRUCTOR = 0x978928ca
+      CONSTRUCTOR = 0x13704a7c
 
-      def initialize(from_peer:, to_peer:, ids:, random_ids: nil)
+      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
+
         result = u32_b(CONSTRUCTOR)
-        result += u32_b(0) # flags
+        result += u32_b(flags)
         result += serialize_input_peer(@from_peer)
         result += u32_b(Constructors::VECTOR) + u32_b(@ids.length)
         @ids.each { |id| result += u32_b(id) }

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetAccessSettings
+      include Binary
+
+      CONSTRUCTOR = 0x213853a3
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      # bot: { id:, access_hash: } or { type: :self }
+      def initialize(bot:)
+        @bot = bot
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += if @bot[:type] == :self
+                    u32_b(INPUT_USER_SELF)
+                  else
+                    u32_b(INPUT_USER) + u64_b(@bot[:id]) + u64_b(@bot[:access_hash] || 0)
+                  end
+        result
+      end
+    end
+  end
+end

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