mtproto 0.0.32 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f20076eea4c2e79508740e13b6f8405437f47ce5ea04f7bffcb55eef0134026
-  data.tar.gz: 3e0ad205973f1f54e8ba60b1b97c4cac1c4a67ea5e59d2b7c797950f943953e0
+  metadata.gz: 8e9121e732982986db9b71a12288993dfb18888e3fe42e2e2b3bb4db55ca494a
+  data.tar.gz: 98b72d7cc330c681c6552a9e3f5b1081e7d614283e685c3f6be70837dae0390b
 SHA512:
-  metadata.gz: 815dbe344577826f6ef0e6d4fac25c0a56eb58f8372f5612c3c77c8f71b9b2684624f3152b3ba4c7f62046dcb239b1bff6ee95b0af98ab249f79a30928abb6cb
-  data.tar.gz: daaf36af66d6cff257881b8ebb3b19ab6c7b6c4bdaa8d7b9ef9f277a7da53539525039380714555948f80112fd46815985c324cbbd6c3075bef8738cf1ef8296
+  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/auth_key_generator.rb

@@ -193,7 +193,9 @@ module MTProto
                                   Digest::SHA1.digest(new_nonce + "\x03".b + auth_key_aux_hash)[-16..]
                                 end
 
-      raise 'new_nonce_hash mismatch!' unless dh_gen_response.new_nonce_hash == expected_new_nonce_hash
+      unless dh_gen_response.new_nonce_hash == expected_new_nonce_hash
+        raise "new_nonce_hash mismatch! (dh_gen #{dh_gen_response.status}, auth_key #{auth_key.bytesize} bytes)"
+      end
 
       case dh_gen_response.status
       when :retry

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/resolve_username'
+require_relative '../../tl/objects/resolved_peer'
+
+module MTProto
+  class Client
+    class API
+      def resolve_username(username:)
+        rpc_call(TL::ResolveUsername.new(username: username), TL::ResolvedPeer).body
+      rescue RpcError => e
+        raise unless e.error_message == 'USERNAME_NOT_OCCUPIED'
+
+        nil
+      end
+    end
+  end
+end

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,7 +17,9 @@ 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'
 require_relative 'api/pin_message'
 require_relative 'api/unpin_all_messages'

data/lib/mtproto/crypto/dh_key_exchange.rb

@@ -29,7 +29,8 @@ module MTProto
         dh_prime = OpenSSL::BN.new(dh_prime_bytes, 2)
 
         auth_key_bn = g_a.mod_exp(b, dh_prime)
-        auth_key_bn.to_s(2)
+        # BN#to_s(2) drops leading zero bytes, and roughly one shared secret in 256 has one.
+        auth_key_bn.to_s(2).rjust(dh_prime_bytes.bytesize, "\x00".b)
       end
 
       def generate_random_2048_bit_number

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

@@ -89,6 +89,7 @@ module MTProto
       CONTACTS_CONTACTS = 0xeae87e42
       CONTACTS_CONTACTS_NOT_MODIFIED = 0xb74ba9d2
       CONTACT = 0x145ade0b
+      CONTACTS_RESOLVED_PEER = 0x7f077ad9
 
       # Messages
       MESSAGES_GET_DIALOGS = 0xa0f4cb4f

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

@@ -27,13 +27,14 @@ module MTProto
         flags = data[offset, 4].unpack1('L<')
         offset += 4
 
-        offset += 4 if flags.anybits?(1 << 0) # tmp_sessions
         offset += 4 if flags.anybits?(1 << 1) # otherwise_relogin_days
+        offset += 4 if flags.anybits?(1 << 0) # tmp_sessions
 
         offset = skip_tl_bytes(data, offset) if flags.anybits?(1 << 2) # future_auth_token
 
-        # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
-        offset += 4 # user constructor
+        user_constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+        raise UnexpectedConstructorError, user_constructor unless user_constructor == Constructors::USER
 
         user_flags = data[offset, 4].unpack1('L<')
         offset += 4

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../schema'
+require_relative '../reader'
+require_relative '../peers'
 require_relative 'message'
-require_relative 'dialogs'
 
 module MTProto
   module TL
@@ -18,8 +18,6 @@ module MTProto
     class ChannelDifference
       attr_reader :type, :final, :pts, :timeout, :new_messages, :chats, :users
 
-      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
-
       # Channel messages ride in new_messages, but message-bearing updates can also
       # appear in other_updates — mine those too, like UpdatesDifference.
       UPDATE_NEW_MESSAGE = 0x1f2b0afd
@@ -35,10 +33,6 @@ module MTProto
         @users = users
       end
 
-      def self.schema
-        @schema ||= Schema.new(SCHEMA_PATH)
-      end
-
       def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
 
@@ -77,10 +71,11 @@ module MTProto
             offset += 4
           end
 
-          messages, offset = parse_messages_vector(data, offset)
+          raw_messages, offset = Message.vector_at(data, offset)
+          messages = raw_messages.map(&:to_h)
           other_messages, offset = parse_other_updates(data, offset)
-          chats, offset = Dialogs.chats_at(data, offset)
-          users, = Dialogs.users_at(data, offset)
+          chats, offset = Peers.chats_at(data, offset)
+          users, = Peers.users_at(data, offset)
 
           new(
             type: :difference,
@@ -107,10 +102,11 @@ module MTProto
             offset += 4
           end
 
-          offset = schema.skip(data, offset) # dialog:Dialog
-          messages, offset = parse_messages_vector(data, offset)
-          chats, offset = Dialogs.chats_at(data, offset)
-          users, = Dialogs.users_at(data, offset)
+          offset = Reader.schema.skip(data, offset) # dialog:Dialog
+          raw_messages, offset = Message.vector_at(data, offset)
+          messages = raw_messages.map(&:to_h)
+          chats, offset = Peers.chats_at(data, offset)
+          users, = Peers.users_at(data, offset)
 
           new(
             type: :too_long,
@@ -122,24 +118,9 @@ module MTProto
           )
         end
 
-        def parse_messages_vector(data, offset)
-          offset += 4 # vector constructor
-          count = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          messages = []
-          count.times do
-            constructor = data[offset, 4].unpack1('L<')
-            msg = Message.deserialize(data, offset, constructor)
-            messages << msg.to_h if msg
-            offset = schema.skip(data, offset)
-          end
-          [messages, offset]
-        end
-
         # other_updates:Vector<Update> — mine message-bearing updates
         # (updateNewMessage/updateNewChannelMessage: the ctor, then an inner Message,
-        # then pts/pts_count), and advance the rest via schema.
+        # then pts/pts_count), and advance the rest via Reader.schema.
         def parse_other_updates(data, offset)
           offset += 4 # vector constructor
           count = data[offset, 4].unpack1('L<')
@@ -153,7 +134,7 @@ module MTProto
               msg = Message.deserialize(data, inner_off, data[inner_off, 4].unpack1('L<'))
               messages << msg.to_h if msg
             end
-            offset = schema.skip(data, offset)
+            offset = Reader.schema.skip(data, offset)
           end
           [messages, offset]
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../schema'
+require_relative '../reader'
+require_relative '../peers'
 
 module MTProto
   module TL
@@ -8,8 +9,6 @@ module MTProto
       Contact = Struct.new(:user_id, :mutual, keyword_init: true)
       User = Struct.new(:id, :first_name, :last_name, :access_hash, keyword_init: true)
 
-      SCHEMA_PATH = File.expand_path('../../../../data/tl-schema.json', __dir__)
-
       attr_reader :contacts, :saved_count, :users, :not_modified
 
       def initialize(contacts: [], saved_count: 0, users: [], not_modified: false)
@@ -23,10 +22,6 @@ module MTProto
         @not_modified
       end
 
-      def self.schema
-        @schema ||= Schema.new(SCHEMA_PATH)
-      end
-
       def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
         return new(not_modified: true) if constructor == Constructors::CONTACTS_CONTACTS_NOT_MODIFIED
@@ -41,9 +36,6 @@ module MTProto
         new(contacts: contacts, saved_count: saved_count, users: users)
       end
 
-      USER_EMPTY = 0xd3bc4b7a
-      private_constant :USER_EMPTY
-
       class << self
         private
 
@@ -68,87 +60,13 @@ module MTProto
           [contacts, offset]
         end
 
-        # 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
-          count = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          users = []
-          count.times do
-            user, offset = parse_user(data, offset)
-            users << user if user
-          end
-          [users, offset]
-        end
-
-        def parse_user(data, offset)
-          constructor = data[offset, 4].unpack1('L<')
-          offset += 4
-
-          if constructor == USER_EMPTY
-            offset += 8
-            return [nil, offset]
+          records, offset = Peers.users_at(data, offset)
+          mapped = records.map do |user|
+            User.new(id: user[:id], first_name: user[:first_name],
+              last_name: user[:last_name], access_hash: user[:access_hash])
           end
-
-          raise "Unknown User constructor: 0x#{constructor.to_s(16)}" unless constructor == Constructors::USER
-
-          flags = data[offset, 4].unpack1('L<')
-          offset += 4
-          flags2 = data[offset, 4].unpack1('L<')
-          offset += 4
-          id = data[offset, 8].unpack1('Q<')
-          offset += 8
-          access_hash = nil
-          if flags.anybits?(1 << 0)
-            access_hash = data[offset, 8].unpack1('Q<')
-            offset += 8
-          end
-
-          first_name = nil
-          first_name, offset = read_tl_string(data, offset) if flags.anybits?(1 << 1)
-          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
-          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
-          offset += 4 if flags.anybits?(1 << 14) # bot_info_version
-          offset = schema.skip_vector(data, offset) { |d, o| schema.skip(d, o) } if flags.anybits?(1 << 18)
-          offset = skip_tl_string(data, offset) if flags.anybits?(1 << 19) # bot_inline_placeholder
-          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)
-          offset += 4 if flags2.anybits?(1 << 5) # stories_max_id
-          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
-
-          [User.new(id: id, first_name: first_name, last_name: last_name, access_hash: access_hash), offset]
-        end
-
-        def read_tl_string(data, offset)
-          first_byte = data.getbyte(offset)
-          if first_byte == 254
-            len = data.getbyte(offset + 1) |
-                  (data.getbyte(offset + 2) << 8) |
-                  (data.getbyte(offset + 3) << 16)
-            total = 4 + len
-          else
-            len = first_byte
-            total = 1 + len
-          end
-          padding = (4 - (total % 4)) % 4
-          [data[offset + (total - len), len].force_encoding('UTF-8'), offset + total + padding]
-        end
-
-        def skip_tl_string(data, offset)
-          _, new_offset = read_tl_string(data, offset)
-          new_offset
+          [mapped, offset]
         end
       end
     end