mtproto 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4d643a3e49ecb3e3d2744952aa42edb40237c2307a0d7d316c1ed350443bab7
-  data.tar.gz: f3f21cb5f49140c69d1d8dd8d34b7b12f2cf0aaaae48efedc9bce6b954cdf1ae
+  metadata.gz: a52707d10eeb5e41cf6e1dcb01374d92092031ceba5f5f92dde31ce4965d174c
+  data.tar.gz: ddf47dbcf9612d686806ec83fd16470de46595300b76c733fc8af37be851f1ff
 SHA512:
-  metadata.gz: ba8f0adc18f691fa85b9722dc994ac1784a30d9465f972f9992da6a95027722655467952c94b31877531c08fb5fa45effef9fc77558ff6b7e2a8cccc69d9310e
-  data.tar.gz: a95133f8932df90e61b39de4cd6342b6d5f5b790bd803eacb3cde964b6d2fbd1e6983fc6f2bfb0543c25568287225e094f10e95bdc52a68fbbc5ff9ebbdc8484
+  metadata.gz: c97f61c1f21c9b2221b90333dd12156b77617e7debd04424a0a4996dd7c50c7b570ba0777d043b966032ad2827db4d70498cc362cd9966c1342bd2b4c711d91c
+  data.tar.gz: 5f235da4dac488f6c9853affca03de93bfecf2b35eacaedf13e933a4400a099e55d1831e2002c63a0687fc326e74c38e86c1e82da9bd9c95c5f07bd41ee846f7

data/lib/mtproto/client/rpc.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+require 'securerandom'
 require_relative '../message_id'
 require_relative 'rpc/response'
 
 module MTProto
   class Client
     class RPC
+      MSGS_ACK = 0x62d6b459
+      VECTOR = 0x1cb5c415
+      PING_DELAY_DISCONNECT = 0xf3427b8c
+
       attr_reader :pending_requests
 
       def initialize(client)
@@ -66,6 +71,34 @@ module MTProto
         @pending_requests.clear
       end
 
+      # Acknowledge received server messages (msgs_ack). Without this the server
+      # keeps the unacknowledged messages, resends them, and drops the connection
+      # after a fixed window. Fire-and-forget — no rpc_result is expected.
+      def send_ack(msg_ids)
+        return if msg_ids.nil? || msg_ids.empty?
+
+        send_encrypted(self.class.ack_body(msg_ids), content_related: false)
+      end
+
+      # Keepalive: ping_delay_disconnect asks the server to disconnect us only if
+      # we stop pinging within disconnect_delay seconds. Fire-and-forget (the pong
+      # is ignored by process_message).
+      def send_ping(disconnect_delay = 75)
+        send_encrypted(self.class.ping_body(SecureRandom.random_number(2**63), disconnect_delay),
+          content_related: false)
+      end
+
+      # Serialized msgs_ack body (no envelope) — extracted for unit testing.
+      def self.ack_body(msg_ids)
+        [MSGS_ACK].pack('L<') + [VECTOR].pack('L<') + [msg_ids.length].pack('L<') +
+          msg_ids.map { |id| [id].pack('Q<') }.join
+      end
+
+      # Serialized ping_delay_disconnect body (no envelope) — extracted for testing.
+      def self.ping_body(ping_id, disconnect_delay)
+        [PING_DELAY_DISCONNECT].pack('L<') + [ping_id].pack('Q<') + [disconnect_delay].pack('l<')
+      end
+
       private
 
       def serialize_request(request)

data/lib/mtproto/client.rb

@@ -77,10 +77,17 @@ module MTProto
       @lang_code = 'en'
 
       @receiver_task = nil
+      @keepalive_task = nil
+      @ack_ids = []
       @running = false
       @on_update_callbacks = []
     end
 
+    # Keepalive cadence: flush pending acks every ACK_INTERVAL seconds, send a
+    # ping every PING_INTERVAL seconds.
+    ACK_INTERVAL = 5
+    PING_INTERVAL = 30
+
     def on_update(&block)
       @on_update_callbacks << block
     end
@@ -111,6 +118,7 @@ module MTProto
       raise 'Mainloop already running' if @running
 
       @running = true
+      @ack_ids = []
       @receiver_task = Async do
         @connection.receive do |packet, error|
           if error
@@ -124,15 +132,20 @@ module MTProto
             sender: :server
           )
 
+          collect_ack(decrypted[:msg_id], decrypted[:seq_no], decrypted[:body])
           process_message(decrypted[:body])
         end
       end
+      @keepalive_task = Async { keepalive_loop }
     end
 
     def disconnect!
       @running = false
+      @keepalive_task&.stop
+      @keepalive_task = nil
       @receiver_task&.stop
       @receiver_task = nil
+      @ack_ids = []
 
       rpc.signal_all_error(Transport::ConnectionError.new('Client shutting down'))
 
@@ -232,6 +245,46 @@ module MTProto
 
     private
 
+    # Periodically acknowledge received messages and ping, so the server doesn't
+    # drop a long-lived connection. Ends when the connection dies (the wrapper
+    # reconnects) or when the task is stopped on disconnect!.
+    def keepalive_loop
+      elapsed = 0
+      loop do
+        sleep ACK_INTERVAL
+        flush_acks
+        elapsed += ACK_INTERVAL
+        next if elapsed < PING_INTERVAL
+
+        elapsed = 0
+        rpc.send_ping
+      end
+    rescue StandardError
+      nil
+    end
+
+    # Queue msg_ids of received content-related server messages for msgs_ack.
+    # A container carries its own inner msg_ids; content-related messages have an
+    # odd seq_no and must be acknowledged (acks/pongs are even and need none).
+    def collect_ack(msg_id, seq_no, body)
+      constructor = body[0, 4].unpack1('L<')
+      if constructor == TL::Constructors::MSG_CONTAINER
+        TL::MsgContainer.deserialize(body).messages.each do |msg|
+          collect_ack(msg[:msg_id], msg[:seqno], msg[:body])
+        end
+      elsif seq_no.odd?
+        @ack_ids << msg_id
+      end
+    end
+
+    def flush_acks
+      return if @ack_ids.empty?
+
+      ids = @ack_ids
+      @ack_ids = []
+      rpc.send_ack(ids)
+    end
+
     def process_message(response_body)
       constructor = response_body[0, 4].unpack1('L<')
 

data/lib/mtproto/tl/constructor_names.rb

@@ -192,6 +192,7 @@ module MTProto
         0x16115a96 => 'pageBlockRelatedArticles',
         0x161d9628 => 'topPeerCategoryChannels',
         0x16484857 => 'account.chatThemes',
+        0x16605e3e => 'messageActionManagedBotCreated',
         0x1662af0b => 'messages.historyImport',
         0x167bd90b => 'payments.starGiftUpgradePreview',
         0x167fc0a1 => 'channels.toggleAutotranslation',
@@ -304,6 +305,7 @@ module MTProto
         0x21108ff7 => 'businessRecipients',
         0x211a1788 => 'webPageEmpty',
         0x21202222 => 'messages.getDialogUnreadMarks',
+        0x213853a3 => 'bots.getAccessSettings',
         0x2144ca19 => 'rpc_error',
         0x21461b5d => 'privacyValueAllowBots',
         0x219c34e6 => 'phone.toggleGroupCallStartSubscription',
@@ -428,6 +430,8 @@ module MTProto
         0x31518e9b => 'messageActionRequestedPeer',
         0x315a4974 => 'users.usersSlice',
         0x316ce548 => 'account.setReactionsNotifySettings',
+        0x31774388 => 'user',
+        0x31813cd8 => 'bots.editAccessSettings',
         0x31bb5d52 => 'channelAdminLogEventActionChangeWallpaper',
         0x31bd492d => 'messages.messageReactionsList',
         0x31c1c44f => 'messages.getMessageReadParticipants',
@@ -525,6 +529,7 @@ module MTProto
         0x3c479971 => 'phone.declineConferenceCallInvite',
         0x3c4f04d8 => 'botCommandScopeUsers',
         0x3c5693e9 => 'inputTheme',
+        0x3c60b621 => 'bots.exportedBotToken',
         0x3cbc93f8 => 'chatParticipants',
         0x3cc04740 => 'messages.deleteQuickReplyShortcut',
         0x3cd930b7 => 'channels.setEmojiStickers',
@@ -616,6 +621,7 @@ module MTProto
         0x47dd8079 => 'messageActionWebViewDataSentMe',
         0x481eadfa => 'emojiListNotModified',
         0x48222faf => 'inputGeoPoint',
+        0x4880ed9a => 'updateManagedBot',
         0x48870999 => 'pageBlockFooter',
         0x4899484e => 'messages.votesList',
         0x48a30254 => 'replyInlineMarkup',
@@ -918,6 +924,7 @@ module MTProto
         0x6c47ac9f => 'langPackStringPluralized',
         0x6c50051c => 'messages.importChatInvite',
         0x6c5a5b37 => 'account.saveWallPaper',
+        0x6c5cf2a7 => 'messages.sendBotRequestedPeer',
         0x6c6274fa => 'messageActionGiftPremium',
         0x6c750de1 => 'messages.sendQuickReplyMessages',
         0x6c8e1e06 => 'birthday',
@@ -1651,6 +1658,7 @@ module MTProto
         0xbc799737 => 'boolFalse',
         0xbcf22685 => 'phone.inviteConferenceCallParticipant',
         0xbd0415c4 => 'stories.togglePeerStoriesHidden',
+        0xbd0d99eb => 'bots.exportBotToken',
         0xbd17a14a => 'topPeerCategoryGroups',
         0xbd1efd3e => 'payments.getStarsGiveawayOptions',
         0xbd2a0840 => 'inputPeerChannelFromMessage',
@@ -1927,6 +1935,7 @@ module MTProto
         0xdcdf8607 => 'stats.getMegagroupStats',
         0xdd0c66f2 => 'starRefProgram',
         0xdd18782e => 'help.appConfig',
+        0xdd1fbf93 => 'bots.accessSettings',
         0xdd289f8e => 'invokeWithBusinessConnection',
         0xdd6a8f48 => 'sendMessageGamePlayAction',
         0xdde8a54c => 'inputPeerUser',
@@ -1999,6 +2008,7 @@ module MTProto
         0xe56dbf05 => 'dialogPeer',
         0xe581e4e9 => 'requirementToContactPremium',
         0xe58e95d2 => 'messages.deleteMessages',
+        0xe5b17f2b => 'bots.createBot',
         0xe5bbfe1a => 'inputMediaPhotoExternal',
         0xe5bdf8de => 'updateUserStatus',
         0xe5bfffcd => 'auth.exportAuthorization',

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
 

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_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_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

@@ -9,16 +9,22 @@ module MTProto
 
       CONSTRUCTOR = 0x978928ca
 
-      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)
         @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
       end
 
       def serialize
+        flags = 0
+        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/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/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_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/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,24 @@ module MTProto
     class SendMedia
       include Binary
 
-      def initialize(peer:, media:, message: '', random_id: nil)
+      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(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 +33,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

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

@@ -9,16 +9,18 @@ module MTProto
 
       INPUT_REPLY_TO_MESSAGE = 0x869fbe10
 
-      def initialize(peer:, message:, random_id: nil, reply_to: nil)
+      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)
@@ -26,6 +28,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/set_bot_commands.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SetBotCommands
+      include Binary
+
+      CONSTRUCTOR = 0x0517165a
+      BOT_COMMAND_SCOPE_DEFAULT = 0x2f6cb2ab
+      BOT_COMMAND = 0xc27ac8c7
+
+      # commands: array of { command:, description: }
+      def initialize(commands:, lang_code: '')
+        @commands = commands
+        @lang_code = lang_code
+      end
+
+      def serialize
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(BOT_COMMAND_SCOPE_DEFAULT)
+        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_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/updates_difference.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 require_relative '../schema'
+require_relative 'dialogs'
 
 module MTProto
   module TL
     class UpdatesDifference
-      attr_reader :type, :date, :seq, :new_messages, :pts, :state
+      attr_reader :type, :date, :seq, :new_messages, :pts, :state, :chats, :users
 
       SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
 
-      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil)
+      def initialize(type:, date: nil, seq: nil, new_messages: [], pts: nil, state: nil, chats: [], users: [])
         @type = type
         @date = date
         @seq = seq
         @new_messages = new_messages
         @pts = pts
         @state = state
+        @chats = chats
+        @users = users
       end
 
       def self.schema
@@ -41,6 +44,11 @@ module MTProto
       MESSAGE_CONSTRUCTOR = Constructors::MESSAGE
       MESSAGE_SERVICE = 0x7a800e0a
       MESSAGE_EMPTY = 0x90a6ca84
+      MESSAGE_REPLY_HEADER = 0x6917560b
+      MEDIA_PHOTO = 0x695150d7
+      MEDIA_DOCUMENT = 0x52d8ccd9
+      UPDATE_NEW_MESSAGE = 0x1f2b0afd
+      UPDATE_NEW_CHANNEL_MESSAGE = 0x62ba04d9
 
       class << self
         private
@@ -53,24 +61,48 @@ module MTProto
           )
         end
 
-        # updates.difference: new_messages new_encrypted_messages other_updates chats users state
+        # updates.difference: new_messages new_encrypted_messages other_updates chats users state.
+        # Channel/supergroup messages arrive in other_updates as
+        # updateNewChannelMessage (not in new_messages), so we mine those too; and
+        # chats/users carry the peers' access_hashes for the bot's peer cache.
         def parse_difference(data, constructor)
           offset = 4
 
           messages, offset = parse_messages_vector(data, offset)
           offset = schema.skip_vector(data, offset) # new_encrypted_messages
-          offset = schema.skip_vector(data, offset) # other_updates
-          offset = schema.skip_vector(data, offset) # chats
-          offset = schema.skip_vector(data, offset) # users
+          other_messages, offset = parse_other_updates(data, offset)
+          chats, offset = Dialogs.chats_at(data, offset)
+          users, offset = Dialogs.users_at(data, offset)
           state = UpdatesState.deserialize(data[offset..])
 
           new(
             type: constructor == Constructors::UPDATES_DIFFERENCE ? :difference : :slice,
-            new_messages: messages,
-            state: state
+            new_messages: messages + other_messages,
+            chats: chats, users: users, state: state
           )
         end
 
+        # other_updates: Vector<Update>. Mine the message-bearing updates
+        # (updateNewMessage / updateNewChannelMessage — each is the update ctor,
+        # then an inner Message, then pts/pts_count); advance the rest via schema.
+        def parse_other_updates(data, offset)
+          offset += 4 # vector constructor
+          count = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          messages = []
+          count.times do
+            ctor = data[offset, 4].unpack1('L<')
+            if [UPDATE_NEW_MESSAGE, UPDATE_NEW_CHANNEL_MESSAGE].include?(ctor)
+              inner_off = offset + 4
+              msg = extract_message(data, inner_off, data[inner_off, 4].unpack1('L<'))
+              messages << msg if msg
+            end
+            offset = schema.skip(data, offset)
+          end
+          [messages, offset]
+        end
+
         def parse_messages_vector(data, offset)
           offset += 4 # vector constructor
           count = data[offset, 4].unpack1('L<')
@@ -97,20 +129,30 @@ module MTProto
           id = data[offset, 4].unpack1('l<')
           offset += 4
 
-          offset = schema.skip(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
+          from_type = from_id = nil
+          from_type, from_id, offset = parse_peer(data, offset) if flags.anybits?(1 << 8) # from_id (Peer)
           offset += 4 if flags.anybits?(1 << 29) # from_boosts_applied
           peer_type, peer_id, offset = parse_peer(data, offset)
           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 flags.anybits?(1 << 3) # reply_to
+
+          is_reply = false
+          reply_to_msg_id = nil
+          if flags.anybits?(1 << 3) # reply_to
+            reply_to_msg_id, is_reply = parse_reply_to(data, offset)
+            offset = schema.skip(data, offset)
+          end
 
           date = data[offset, 4].unpack1('L<')
           offset += 4
-          message_text, = read_tl_string(data, offset)
+          message_text, offset = read_tl_string(data, offset)
+          media = flags.anybits?(1 << 9) ? parse_media(data, offset) : nil
 
-          { id: id, date: date, message: message_text, peer_type: peer_type, peer_id: peer_id }
+          { 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, is_reply: is_reply, reply_to_msg_id: reply_to_msg_id }
         end
 
         def parse_peer(data, offset)
@@ -129,6 +171,43 @@ module MTProto
           end
         end
 
+        # messageReplyHeader: ctor, flags, reply_to_msg_id:flags.4?int (first payload
+        # field). A plain message in a forum topic carries this header (forum_topic
+        # flags.3) but is a reply only when it targets a message in the topic
+        # (reply_to_top_id flags.1). => [reply_to_msg_id, is_reply]
+        def parse_reply_to(data, offset)
+          return [nil, false] unless data[offset, 4].unpack1('L<') == MESSAGE_REPLY_HEADER
+
+          io = offset + 4
+          flags = data[io, 4].unpack1('L<')
+          io += 4
+          forum_topic = flags.anybits?(1 << 3)
+          msg_id = flags.anybits?(1 << 4) ? data[io, 4].unpack1('l<') : nil
+          [msg_id, forum_topic ? flags.anybits?(1 << 1) : true]
+        rescue StandardError
+          [nil, false]
+        end
+
+        # Classify message media into :photo / :video / :audio / :document, or nil.
+        def parse_media(data, offset)
+          case data[offset, 4].unpack1('L<')
+          when MEDIA_PHOTO
+            :photo
+          when MEDIA_DOCUMENT
+            document_kind(data[offset + 4, 4].unpack1('L<'))
+          end
+        rescue StandardError
+          nil
+        end
+
+        # messageMediaDocument flags: video flags.6 / round flags.7 / voice flags.8.
+        def document_kind(flags)
+          return :video if flags.anybits?(1 << 6) || flags.anybits?(1 << 7)
+          return :audio if flags.anybits?(1 << 8)
+
+          :document
+        end
+
         def read_tl_string(data, offset)
           first_byte = data.getbyte(offset)
           if first_byte == 254

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class UploadProfilePhoto
+      include Binary
+
+      CONSTRUCTOR = 0x0388a3b5
+      INPUT_USER = 0xf21158c6
+      INPUT_USER_SELF = 0xf7c1b13f
+      INPUT_FILE = 0xf52ff27f
+
+      # bot: { id:, access_hash: } or { type: :self }; nil targets the calling bot
+      # file: { id:, parts:, name:, md5_checksum: }
+      def initialize(file:, bot: nil)
+        @bot = bot
+        @file = file
+      end
+
+      def serialize
+        flags = (1 << 0) # file
+        flags |= (1 << 5) if @bot
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_input_user(@bot) if @bot
+        result += serialize_input_file(@file)
+        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_input_file(file)
+        u32_b(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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.14'
+  VERSION = '0.0.15'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Artem Levenkov
@@ -108,12 +108,17 @@ files:
 - lib/mtproto/tl/objects/check_password.rb
 - lib/mtproto/tl/objects/client_dh_inner_data.rb
 - lib/mtproto/tl/objects/contacts.rb
+- lib/mtproto/tl/objects/create_bot.rb
 - lib/mtproto/tl/objects/delete_messages.rb
 - lib/mtproto/tl/objects/dh_gen_response.rb
 - lib/mtproto/tl/objects/dialogs.rb
+- lib/mtproto/tl/objects/edit_access_settings.rb
 - lib/mtproto/tl/objects/edit_message.rb
+- lib/mtproto/tl/objects/export_bot_token.rb
 - lib/mtproto/tl/objects/export_login_token.rb
+- lib/mtproto/tl/objects/exported_bot_token.rb
 - lib/mtproto/tl/objects/forward_messages.rb
+- lib/mtproto/tl/objects/get_access_settings.rb
 - lib/mtproto/tl/objects/get_channel_difference.rb
 - lib/mtproto/tl/objects/get_config.rb
 - lib/mtproto/tl/objects/get_contacts.rb
@@ -132,21 +137,26 @@ files:
 - lib/mtproto/tl/objects/import_bot_authorization.rb
 - lib/mtproto/tl/objects/import_login_token.rb
 - lib/mtproto/tl/objects/init_connection.rb
+- lib/mtproto/tl/objects/input_keyboard_button_request_peer.rb
 - lib/mtproto/tl/objects/invite_to_channel.rb
 - lib/mtproto/tl/objects/invoke_with_layer.rb
 - lib/mtproto/tl/objects/login_token.rb
 - lib/mtproto/tl/objects/message.rb
 - lib/mtproto/tl/objects/messages.rb
+- lib/mtproto/tl/objects/messages_get_messages.rb
 - lib/mtproto/tl/objects/msg_container.rb
 - lib/mtproto/tl/objects/new_session_created.rb
 - lib/mtproto/tl/objects/pq_inner_data.rb
 - lib/mtproto/tl/objects/raw_response.rb
+- lib/mtproto/tl/objects/reply_keyboard_markup.rb
 - lib/mtproto/tl/objects/req_dh_params.rb
 - lib/mtproto/tl/objects/req_pq_multi.rb
+- lib/mtproto/tl/objects/request_peer_type_create_bot.rb
 - lib/mtproto/tl/objects/res_pq.rb
 - lib/mtproto/tl/objects/resolve_username.rb
 - lib/mtproto/tl/objects/rpc_error.rb
 - lib/mtproto/tl/objects/save_file_part.rb
+- lib/mtproto/tl/objects/send_bot_requested_peer.rb
 - lib/mtproto/tl/objects/send_code.rb
 - lib/mtproto/tl/objects/send_media.rb
 - lib/mtproto/tl/objects/send_message.rb
@@ -154,6 +164,8 @@ files:
 - lib/mtproto/tl/objects/sent_code.rb
 - lib/mtproto/tl/objects/server_dh_inner_data.rb
 - lib/mtproto/tl/objects/server_dh_params.rb
+- lib/mtproto/tl/objects/set_bot_commands.rb
+- lib/mtproto/tl/objects/set_bot_info.rb
 - lib/mtproto/tl/objects/set_client_dh_params.rb
 - lib/mtproto/tl/objects/sign_in.rb
 - lib/mtproto/tl/objects/update.rb
@@ -163,6 +175,7 @@ files:
 - lib/mtproto/tl/objects/update_username.rb
 - lib/mtproto/tl/objects/updates_difference.rb
 - lib/mtproto/tl/objects/updates_state.rb
+- lib/mtproto/tl/objects/upload_profile_photo.rb
 - lib/mtproto/tl/objects/users.rb
 - lib/mtproto/tl/schema.rb
 - lib/mtproto/transport/abridged_packet_codec.rb