mtproto 0.0.33 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc4ebf89bbc3d69e0b542b04320af0e74acdd828279411bad647e995a5aad06d
-  data.tar.gz: acb092bf151f543578359c1bcd9d81ff1a2f6bc20e5935276a5c8a7b117892ec
+  metadata.gz: 8e9121e732982986db9b71a12288993dfb18888e3fe42e2e2b3bb4db55ca494a
+  data.tar.gz: 98b72d7cc330c681c6552a9e3f5b1081e7d614283e685c3f6be70837dae0390b
 SHA512:
-  metadata.gz: da18a3d97b307eee7bc93ce71efe179a571c4a6385c94a81b43e6dc8e950aabc002fe31b4312b51a1d91157bb3e102b11ce213409eb4ebafbc37db998dd528ab
-  data.tar.gz: cdc1d6a7bd55e8ca66841e43e6f40ec8bdfcd950a7c2bad5325dc8dff2f5d4aecb9eb948d76b7787f3c36a255fc5301830145820037c7e9fc5660459747dadd1
+  metadata.gz: 9a6fe6fc4c86420ee93a35f44f21fc39778b28fbc7a4c92e2294545dde285de72683db01a282e0517e5b8f4172af211465d17d7141185637d90fccba67b12b7b
+  data.tar.gz: 276c70eaffb140cd6b8d5f34582f9009c205d00e46afbefdd5f6050c67e79600c1afd6c5238f38d7cd8121fe0fb611b09a00b5237017bbcb69bc9df2d3e6cbd8

data/docs/test_architecture_level1.md

@@ -22,11 +22,13 @@ once.
 
 ## How It Works
 
-These are semi-manual tests. Each test case:
+Each test case is a script that drives the whole scenario itself:
 
-1. Connects to Telegram with a pre-authenticated session
-2. Tells the user what to do (e.g., "Send a text message to this account")
-3. Waits until the corresponding data arrives from Telegram
+1. Connects to Telegram with pre-authenticated sessions — one per side the
+   scenario needs (a user, a bot, a second user)
+2. Performs the user-facing actions from those sessions, so no operator has to
+   do anything by hand
+3. Waits out the traffic the actions produce
 4. Saves the raw decrypted message bodies as `.bin` files and a `captured.json`
    listing the TL constructors received
 
@@ -112,11 +114,11 @@ No metadata file — the folder + filename are the catalogue.
 
 ## File Structure
 
-Each scenario is an executable script (not an RSpec spec). The flow is
-interactive — the script prints instructions, waits on STDIN, then captures
-the resulting Telegram traffic. RSpec's declarative `describe`/`it` shape
-doesn't fit that, so these scripts live under `spec/level1/` alongside the
-rspec tree but are invoked directly, not through `rake spec`.
+Each scenario is an executable script (not an RSpec spec). It talks to live
+Telegram, needs credentials, and narrates what it observes as it goes —
+RSpec's declarative `describe`/`it` shape fits none of that, so these scripts
+live under `spec/level1/` alongside the rspec tree, are invoked directly, and
+never run as part of `rake spec`.
 
 ```
 spec/
@@ -131,107 +133,21 @@ spec/
       constructors/                # Deduplicated constructor variant library
 ```
 
-## Running with xp
-
-These scripts are interactive — they print a prompt, block on STDIN, run
-until the captured traffic arrives, then exit. When the operator is a
-Claude Code bot driving the repo from short-lived Bash invocations, a
-plain shell can't keep the script alive across calls: each tool call is
-a fresh process, so the script would exit (or be killed) the moment the
-shell returns.
-
-The way around it is [xp](https://github.com/alev-pro/xp) — a small
-process stdin/stdout multiplexer. A long-lived xp daemon owns the
-script under a named topic; separate client invocations send to its
-stdin and read from its stdout. The script keeps running between
-calls.
-
-The recipe below assumes xp is built at
-`~/devel/alev-pro/xp/target/release/xp`. Adjust the path if it lives
-elsewhere.
-
-### 1. Start the xp daemon
-
-```sh
-nohup ~/devel/alev-pro/xp/target/release/xp --run-daemon \
-  >/tmp/xp-daemon.log 2>&1 &
-echo $! > /tmp/xp-daemon.pid
-```
-
-The daemon binds a Unix socket at `/tmp/xp-<uid>.sock`. The PID file
-is just a convention so teardown can `kill` by PID — `pkill -f` on
-the daemon command line is dangerous because it can also match the
-caller's own wrapper shell.
-
-### 2. Spawn the Level 1 script under a topic
+## Running a scenario
 
 ```sh
-~/devel/alev-pro/xp/target/release/xp -t l1 -- \
-  bash -lc 'cd ~/devel/alev-pro/mtproto-ruby \
-            && bundle exec spec/level1/receive_private_text_message'
+cd ~/devel/alev-pro/mtproto-ruby
+bundle exec spec/level1/<scenario>
 ```
 
-`l1` is just a chosen topic name. Any string works.
-
-### 3. Read the script's stdout
-
-```sh
-~/devel/alev-pro/xp/target/release/xp -t l1 --read-stdout --cursor c1
-```
-
-`--cursor c1` keeps a stable read position across separate xp client
-invocations. Without `--cursor`, xp keys the cursor on the caller's
-posix session id (`getsid(0)`), and every fresh Bash tool call has a
-new sid — meaning every read replays the buffer from byte 0.
-
-Expected initial output:
-
-```
-Connecting...
-Connected as: <first> <last>
-Send a text message to this account in a private chat.
-Press Enter when done.
-```
+The script runs to completion on its own and exits; nothing has to be typed at
+it. It reads its credentials from the environment (`.env` is loaded): the test
+DC address, key and number, the API id and hash, and one or more
+pre-authenticated sessions. Each script names the variables it needs.
 
-### 4. Trigger the scenario
-
-Perform the user-facing action the script asks for (in this case,
-send a private text message to the test-DC account from another
-Telegram client).
-
-### 5. Unblock the script
-
-```sh
-echo "" | ~/devel/alev-pro/xp/target/release/xp -t l1 --put-to-stdin
-```
-
-The script then prints the captured constructor list and writes the
-fixtures + `captured.json` to `spec/fixtures/level1/test_cases/<scenario>/`.
-
-### 6. Tear down
-
-```sh
-kill "$(cat /tmp/xp-daemon.pid)"
-rm -f /tmp/xp-<uid>.sock /tmp/xp-daemon.pid
-```
-
-### STDOUT buffering caveat
-
-Ruby's `STDOUT` defaults to full buffering when stdout is not a tty,
-and xp pipes the child's stdout through a plain pipe rather than a
-pty. Without an explicit flush the script's `puts` calls would stay
-in-process until exit, and step 3 would read nothing. Each Level 1
-script must therefore set `STDOUT.sync = true` near the top, before
-any output.
-
-### `bash -lc` noise
-
-When `bash -i` runs under xp without a pty, it complains:
-
-```
-bash: cannot set terminal process group (...): Inappropriate ioctl for device
-bash: no job control in this shell
-```
+### STDOUT buffering
 
-That noise lands on stderr, which the daemon inherits and writes into
-`/tmp/xp-daemon.log`. The script's own stdout stays clean.
+Ruby's `STDOUT` defaults to full buffering when stdout is not a tty, so a script
+whose output is piped or captured would hold everything in-process until it
+exits. Each Level 1 script therefore sets `STDOUT.sync = true` near the top,
+before any output.

data/lib/mtproto/client/api/send_message.rb

@@ -16,14 +16,17 @@ module MTProto
       #     it (`message`/`entities` are ignored). Note: server-gated (premium).
       # A `reply_to` (with optional `quote_text`/`quote_offset`) replies to a message,
       # optionally pinning the quoted fragment.
+      # `silent:` delivers without the recipient's notification sound — for a message that
+      # is not news to them: a transcript of what they just said, a repaint of something
+      # already on screen.
       def send_message(peer:, message: '', random_id: nil, reply_to: nil, entities: nil,
                        parse_mode: nil, rich_markdown: nil, quote_text: nil, quote_offset: nil, no_webpage: false,
-                       reply_markup: nil)
+                       reply_markup: nil, silent: false)
         message, entities = Markdown.parse(message) if parse_mode && entities.nil? && rich_markdown.nil?
         rpc_call(
           TL::SendMessage.new(peer: peer, message: message, random_id: random_id, reply_to: reply_to,
             entities: entities, rich_markdown: rich_markdown, quote_text: quote_text, quote_offset: quote_offset,
-            no_webpage: no_webpage, reply_markup: reply_markup),
+            no_webpage: no_webpage, reply_markup: reply_markup, silent: silent),
           TL::UpdateShortSentMessage
         ).body
       end

data/lib/mtproto/client/api/set_typing.rb

@@ -8,11 +8,11 @@ module MTProto
   class Client
     class API
       # messages.setTyping — show a chat action in `peer`. `action` is a
-      # SendMessageAction type symbol (default :typing) or a prebuilt object (pass
-      # an object to carry upload progress). `top_msg_id` targets a forum topic /
-      # thread. Returns the raw Bool reply, normally ignored.
+      # SendMessageAction type symbol (default :typing), or any object that
+      # serializes itself. `top_msg_id` targets a forum topic / thread. Returns
+      # the raw Bool reply, normally ignored.
       def set_typing(peer:, action: :typing, top_msg_id: nil)
-        action = TL::SendMessageAction.new(action) unless action.is_a?(TL::SendMessageAction)
+        action = TL::SendMessageAction.new(action) if action.is_a?(Symbol)
         rpc_call(
           TL::SetTyping.new(peer: peer, action: action, top_msg_id: top_msg_id),
           TL::RawResponse

data/lib/mtproto/client/api/stream_draft.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../draft_stream'
+
+module MTProto
+  class Client
+    class API
+      def stream_draft(peer:, random_id: nil, top_msg_id: nil)
+        DraftStream.new(api: self, peer: peer, random_id: random_id, top_msg_id: top_msg_id)
+      end
+    end
+  end
+end

data/lib/mtproto/client/api.rb

@@ -17,6 +17,7 @@ require_relative 'api/get_channel_difference'
 require_relative 'api/get_bot_callback_answer'
 require_relative 'api/send_message'
 require_relative 'api/set_typing'
+require_relative 'api/stream_draft'
 require_relative 'api/get_contacts'
 require_relative 'api/resolve_username'
 require_relative 'api/export_bot_token'

data/lib/mtproto/draft_stream.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'tl/objects/send_message_text_draft_action'
+
+module MTProto
+  # Telegram caps the underlying call at 20 per 5s and 40 per 30s per peer, and
+  # breaching that returns FLOOD_WAIT and blocks what follows. A frame with no room
+  # left is therefore dropped rather than queued — the next frame carries newer text
+  # anyway.
+  class DraftStream
+    WINDOWS = [[5.0, 20], [30.0, 40]].freeze
+
+    attr_reader :random_id
+
+    def initialize(api:, peer:, random_id: nil, top_msg_id: nil, clock: nil)
+      @api = api
+      @peer = peer
+      @random_id = random_id || SecureRandom.random_number(2**63)
+      @top_msg_id = top_msg_id
+      @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+      @sent_at = []
+    end
+
+    def update(text, entities: [])
+      now = @clock.call
+      return false unless room?(now)
+
+      @api.set_typing(
+        peer: @peer, top_msg_id: @top_msg_id,
+        action: TL::SendMessageTextDraftAction.new(random_id: @random_id, text: text, entities: entities)
+      )
+      @sent_at << now
+      true
+    rescue RpcError
+      false
+    end
+
+    # Send the finished answer as an ordinary message, which also clears the draft.
+    def finish(text, **)
+      @api.send_message(peer: @peer, message: text, **)
+    end
+
+    private
+
+    def room?(now)
+      longest = WINDOWS.map(&:first).max
+      @sent_at.reject! { |at| now - at >= longest }
+      WINDOWS.all? { |span, cap| @sent_at.count { |at| now - at < span } < cap }
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    # The pieces every media-carrying call writes the same way: who it is addressed to,
+    # the file just uploaded, and the strings around it.
+    #
+    # Held together here because an album is sent in two calls — one to turn each upload
+    # into a photo Telegram holds, one to send them as a group — and both write the same
+    # peer and the same file.
+    module MediaParts
+      include Binary
+
+      INPUT_MEDIA_PHOTO = 0xe3af4434
+      INPUT_PHOTO = 0x3bb3b94a
+
+      def serialize_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
+
+      def serialize_uploaded_photo(file)
+        u32_b(Constructors::INPUT_MEDIA_UPLOADED_PHOTO) + u32_b(0) + serialize_file(file)
+      end
+
+      # A photo Telegram already holds, named by what it answered when the upload was
+      # handed to it.
+      def serialize_held_photo(photo)
+        u32_b(INPUT_MEDIA_PHOTO) + u32_b(0) +
+          u32_b(INPUT_PHOTO) + u64_b(photo[:id]) + u64_b(photo[:access_hash]) +
+          serialize_raw(photo[:file_reference])
+      end
+
+      def serialize_file(file)
+        return u32_b(Constructors::INPUT_FILE_BIG) + u64_b(file[:id]) + u32_b(file[:parts]) +
+               serialize_text(file[:name].to_s) if file[:big]
+
+        u32_b(Constructors::INPUT_FILE) + u64_b(file[:id]) + u32_b(file[:parts]) +
+          serialize_text(file[:name].to_s) + serialize_text(file[:md5_checksum].to_s)
+      end
+
+      def serialize_text(str)
+        serialize_byte_array(str.encode('UTF-8').bytes)
+      end
+
+      def serialize_raw(raw)
+        serialize_byte_array(raw.to_s.b.bytes)
+      end
+
+      def serialize_byte_array(bytes)
+        length = bytes.length
+        head = length <= 253 ? [length] : [254] + u32_b(length)[0, 3]
+        padded = head + bytes
+        padded + [0] * ((4 - (padded.length % 4)) % 4)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ReplyKeyboardForceReply
+      include Binary
+
+      CONSTRUCTOR = 0x86b40b08
+
+      def initialize(single_use: false, selective: false, placeholder: nil)
+        @single_use = single_use
+        @selective = selective
+        @placeholder = placeholder
+      end
+
+      def serialize
+        flags = 0
+        flags |= (1 << 1) if @single_use
+        flags |= (1 << 2) if @selective
+        flags |= (1 << 3) if @placeholder
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += serialize_tl_string(@placeholder) if @placeholder
+        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_message_text_draft_action.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../message_entity'
+
+module MTProto
+  module TL
+    # A SendMessageAction carrying a live draft: the partially generated answer the
+    # recipient's client shows at the bottom of the chat while it is still being
+    # written. Unlike the other actions it is not a bare constructor id, so it does
+    # not fit TL::SendMessageAction's id-plus-progress table.
+    #
+    # `random_id` identifies the draft: the same value updates the draft already on
+    # screen, a different one puts a second draft beside it.
+    class SendMessageTextDraftAction
+      include Binary
+
+      CONSTRUCTOR = 0x376d975c
+      TEXT_WITH_ENTITIES = 0x751f3146
+
+      def initialize(random_id:, text:, entities: [])
+        @random_id = random_id
+        @text = text
+        @entities = entities
+      end
+
+      # textWithEntities#751f3146 text:string entities:Vector<MessageEntity> — the
+      # entity vector is not optional, so an empty list still goes on the wire.
+      def serialize
+        u32_b(CONSTRUCTOR) + u64_b(@random_id) +
+          u32_b(TEXT_WITH_ENTITIES) + serialize_tl_string(@text) +
+          MessageEntities.serialize(@entities)
+      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_multi_media.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'media_parts'
+
+module MTProto
+  module TL
+    # messages.sendMultiMedia — several photos as ONE message, the way a person sends an
+    # album.
+    #
+    # The words ride on the first of them and nowhere else: an album carries a single
+    # caption, and repeating it under each picture is how it looks when somebody sends
+    # them one at a time.
+    class SendMultiMedia
+      include MediaParts
+
+      CONSTRUCTOR = 0x1bf89d74
+      INPUT_SINGLE_MEDIA = 0x1cc6e91f
+      INPUT_REPLY_TO_MESSAGE = 0x3bd4b7c2
+
+      def initialize(peer:, photos:, message: '', reply_to: nil, silent: false)
+        @peer = peer
+        @photos = photos
+        @message = message
+        @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(CONSTRUCTOR) + u32_b(flags) + serialize_peer(@peer)
+        result += u32_b(INPUT_REPLY_TO_MESSAGE) + u32_b(0) + u32_b(@reply_to) if @reply_to
+        result += u32_b(Constructors::VECTOR) + u32_b(@photos.length)
+        @photos.each_with_index { |photo, nth| result += serialize_single(photo, nth) }
+        result
+      end
+
+      private
+
+      def serialize_single(photo, nth)
+        u32_b(INPUT_SINGLE_MEDIA) + u32_b(0) +
+          serialize_held_photo(photo) +
+          u64_b(SecureRandom.random_number(2**63)) +
+          serialize_text(nth.zero? ? @message.to_s : '')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'media_parts'
+
+module MTProto
+  module TL
+    # messages.uploadMedia — hand Telegram an upload and get back the photo it now holds.
+    #
+    # The step before an album: a group is sent by naming photos Telegram already has, so
+    # each file is offered once on its own before the group is sent at all.
+    class UploadMedia
+      include MediaParts
+
+      CONSTRUCTOR = 0x14967978
+
+      def initialize(peer:, file:)
+        @peer = peer
+        @file = file
+      end
+
+      def serialize
+        u32_b(CONSTRUCTOR) + u32_b(0) + serialize_peer(@peer) + serialize_uploaded_photo(@file)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/peers.rb

@@ -7,7 +7,7 @@ module MTProto
     module Peers
       module_function
 
-      Chat = Struct.new(:id, :title, :type, :access_hash, :username, keyword_init: true)
+      Chat = Struct.new(:id, :title, :type, :access_hash, :username, :min, keyword_init: true)
 
       def chats_at(data, offset)
         offset += 4 # vector constructor
@@ -119,7 +119,8 @@ module MTProto
         offset += 8 if flags2.anybits?(1 << 18) # linked_monoforum_id (long)
 
         type = flags.anybits?(1 << 8) ? :supergroup : :channel
-        [Chat.new(id: id, title: title, type: type, access_hash: access_hash, username: username), offset]
+        [Chat.new(id: id, title: title, type: type, access_hash: access_hash, username: username,
+          min: flags.anybits?(1 << 12)), offset]
       end
 
       # chatForbidden#6592a1a7 id:long title:string
@@ -192,8 +193,8 @@ module MTProto
         offset += 4
         id = data[offset, 8].unpack1('Q<')
         offset += 8
-        access_hash = nil
-        if flags.anybits?(1 << 0)
+        carries_hash = flags.anybits?(1 << 0)
+        if carries_hash
           access_hash = data[offset, 8].unpack1('Q<')
           offset += 8
         end
@@ -223,8 +224,10 @@ module MTProto
         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, username: username,
-           is_bot: flags.anybits?(1 << 14), access_hash: access_hash }, offset]
+        user = { id: id, first_name: first_name, last_name: last_name, username: username,
+                 is_bot: flags.anybits?(1 << 14), min: flags.anybits?(1 << 20) }
+        user[:access_hash] = access_hash if carries_hash
+        [user, offset]
       end
       private_class_method :parse_chat, :parse_basic_chat, :parse_channel,
         :parse_chat_forbidden, :parse_channel_forbidden, :parse_user

data/lib/mtproto/tl/reader.rb

@@ -18,6 +18,9 @@ module MTProto
       MEDIA_DOCUMENT = 0x52d8ccd9
       DOCUMENT = 0x8fd4c4d8
       PHOTO = 0xfb197a65
+      PHOTO_SIZE = 0x75c78e60
+      PHOTO_CACHED_SIZE = 0x021e1ad6
+      PHOTO_SIZE_PROGRESSIVE = 0xfa3efb95
       DOCUMENT_ATTRIBUTE_AUDIO = 0x9852f9c6
       DOCUMENT_ATTRIBUTE_FILENAME = 0x15590068
 
@@ -158,13 +161,37 @@ module MTProto
         id = data[offset, 8].unpack1('q<')
         access_hash = data[offset + 8, 8].unpack1('q<')
         offset += 16
-        file_reference, = read_tl_bytes(data, offset)
+        file_reference, offset = read_tl_bytes(data, offset)
 
-        { id: id, access_hash: access_hash, file_reference: file_reference }
+        { id: id, access_hash: access_hash, file_reference: file_reference,
+          sizes: photo_sizes(data, offset + 4) } # +4: date, which precedes the sizes
       rescue StandardError
         nil
       end
 
+      # Every size Telegram holds this photo in, by the name upload.getFile asks for it.
+      #
+      # A photo, unlike a document, is not fetched whole: the location names which size is
+      # wanted, and naming none is answered as if the reference had gone stale — which is
+      # what makes a missing size look like an expired one.
+      #
+      # Only the sizes with a width can be fetched: the other kinds carry their own bytes
+      # inline (a blur, an outline) and have nothing to ask for.
+      SIZES_WITH_WIDTH = [PHOTO_SIZE, PHOTO_CACHED_SIZE, PHOTO_SIZE_PROGRESSIVE].freeze
+
+      def photo_sizes(data, offset)
+        found = []
+        schema.skip_vector(data, offset) do |bytes, at|
+          constructor = bytes[at, 4].unpack1('L<')
+          name, after = read_tl_string(bytes, at + 4)
+          found << { type: name, width: bytes[after, 4].unpack1('l<') } if SIZES_WITH_WIDTH.include?(constructor)
+          schema.skip(bytes, at)
+        end
+        found
+      rescue StandardError
+        []
+      end
+
       # Vector<DocumentAttribute>: pull voice/duration from documentAttributeAudio
       # and the name from documentAttributeFilename; advance over the rest via
       # schema so an unknown attribute never throws off the read.

data/lib/mtproto/updates/state_machine.rb

@@ -51,14 +51,14 @@ module MTProto
 
       def dispatch(batch, &)
         remember_channels(batch.chats)
-        batch.events.each { |event| ingest(event, &) }
+        batch.events.each { |event| ingest(event, batch, &) }
         batch.channel_too_long.each { |channel_id| recover_channel(channel_id, &) }
         catch_up(&) if batch.too_long
       end
 
-      def ingest(event, &)
+      def ingest(event, batch, &)
         detect_gap(event, &)
-        emit(event, &)
+        emit(event, batch, &)
       end
 
       # A live update whose pts jumps past our stored position means updates were
@@ -80,11 +80,11 @@ module MTProto
       # host's transaction (atomic with the host's own handling); the in-memory @pts is
       # advanced only AFTER the transaction commits, so a rollback can never leave the
       # cache ahead of the store and silently drop later account updates.
-      def emit(event, &block)
+      def emit(event, batch, &block)
         return if outdated?(event)
 
         @store.transaction do
-          block.call(event)
+          block.call(event, batch)
           checkpoint(event)
         end
         cache_account_position(event)
@@ -142,7 +142,7 @@ module MTProto
 
       def apply_difference(diff, &)
         remember_channels(diff.chats)
-        diff.events.each { |event| emit(event, &) }
+        diff.events.each { |event| emit(event, diff, &) }
         diff.channel_too_long.each { |channel_id| recover_channel(channel_id, &) }
         @pts = diff.pts if diff.pts
         @qts = diff.qts if diff.qts
@@ -164,7 +164,7 @@ module MTProto
           return catch_up(&) if diff.type == :too_long
 
           remember_channels(diff.chats)
-          diff.events.each { |event| emit(event, &) }
+          diff.events.each { |event| emit(event, diff, &) }
           if diff.pts&.positive?
             from = diff.pts
             @store.set_channel_pts(channel_id, diff.pts)

data/lib/mtproto/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.33
+  version: 0.0.34
 platform: ruby
 authors:
 - Artem Levenkov
@@ -85,6 +85,7 @@ files:
 - lib/mtproto/client/api/send_message.rb
 - lib/mtproto/client/api/set_typing.rb
 - lib/mtproto/client/api/sign_in.rb
+- lib/mtproto/client/api/stream_draft.rb
 - lib/mtproto/client/api/unpin_all_messages.rb
 - lib/mtproto/client/rpc.rb
 - lib/mtproto/client/rpc/response.rb
@@ -100,6 +101,7 @@ files:
 - lib/mtproto/crypto/srp.rb
 - lib/mtproto/dc.rb
 - lib/mtproto/delegate_methods.rb
+- lib/mtproto/draft_stream.rb
 - lib/mtproto/encrypted_message.rb
 - lib/mtproto/errors.rb
 - lib/mtproto/file_downloader.rb
@@ -170,6 +172,7 @@ files:
 - lib/mtproto/tl/objects/invoke_with_layer.rb
 - lib/mtproto/tl/objects/keyboard_button_callback.rb
 - lib/mtproto/tl/objects/login_token.rb
+- lib/mtproto/tl/objects/media_parts.rb
 - lib/mtproto/tl/objects/message.rb
 - lib/mtproto/tl/objects/message_service.rb
 - lib/mtproto/tl/objects/messages.rb
@@ -181,6 +184,7 @@ files:
 - lib/mtproto/tl/objects/pq_inner_data.rb
 - lib/mtproto/tl/objects/raw_response.rb
 - lib/mtproto/tl/objects/reply_inline_markup.rb
+- lib/mtproto/tl/objects/reply_keyboard_force_reply.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
@@ -198,6 +202,8 @@ files:
 - lib/mtproto/tl/objects/send_media.rb
 - lib/mtproto/tl/objects/send_message.rb
 - lib/mtproto/tl/objects/send_message_action.rb
+- lib/mtproto/tl/objects/send_message_text_draft_action.rb
+- lib/mtproto/tl/objects/send_multi_media.rb
 - lib/mtproto/tl/objects/send_reaction.rb
 - lib/mtproto/tl/objects/sent_code.rb
 - lib/mtproto/tl/objects/server_dh_inner_data.rb
@@ -220,6 +226,7 @@ files:
 - lib/mtproto/tl/objects/updates.rb
 - lib/mtproto/tl/objects/updates_difference.rb
 - lib/mtproto/tl/objects/updates_state.rb
+- lib/mtproto/tl/objects/upload_media.rb
 - lib/mtproto/tl/objects/upload_profile_photo.rb
 - lib/mtproto/tl/objects/users.rb
 - lib/mtproto/tl/peers.rb