mtproto 0.0.13 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef5c11c5bf0b9bfe4f3b80e905270264b5658bc55a2932e92c945df8ba0dc723
-  data.tar.gz: 58fec06d053d66b52c382049e7fb917dbf0c4af2395c7f81f5dcb66d70778228
+  metadata.gz: a52707d10eeb5e41cf6e1dcb01374d92092031ceba5f5f92dde31ce4965d174c
+  data.tar.gz: ddf47dbcf9612d686806ec83fd16470de46595300b76c733fc8af37be851f1ff
 SHA512:
-  metadata.gz: b108736ec52172e501b8609b6c8b5596052b7fa80d72bfaa6cadb393baddbe89ec009148da487f3b8c16b9a6000e5bdea4aa5b15c77fd9ddd19ce43ae8db6763
-  data.tar.gz: 3268f1b6943ea7c470ee274a56cbc3e4d3c5a2aebff7e8b5b4522805e8a922756932cb396909650f520cb3153d75d8e34a61e5952916602421ed01df2b9e5c7e
+  metadata.gz: c97f61c1f21c9b2221b90333dd12156b77617e7debd04424a0a4996dd7c50c7b570ba0777d043b966032ad2827db4d70498cc362cd9966c1342bd2b4c711d91c
+  data.tar.gz: 5f235da4dac488f6c9853affca03de93bfecf2b35eacaedf13e933a4400a099e55d1831e2002c63a0687fc326e74c38e86c1e82da9bd9c95c5f07bd41ee846f7

data/FUTURE.md

@@ -0,0 +1,9 @@
+# Future Tasks
+
+## Implement msgs_ack
+
+Client should acknowledge received messages by sending `msgs_ack` with a list of received
+msg_ids. Without this, the server may redeliver messages it considers unacknowledged.
+
+Also add handling for `bad_msg_notification` responses from the server (constructor exists
+in constructors.rb but no handler in Client#process_message).

data/docs/test_architecture_level1.md

@@ -0,0 +1,237 @@
+# Level 1 Test Architecture: Constructor Capture and Test Cases
+
+## Purpose
+
+Collect real data from Telegram in specific user-facing scenarios and use it as the
+source for two things:
+
+1. **A library of TL constructor variants**: every concrete form of every constructor
+   we ever observe (across all the optional fields and flag-driven shapes) — stored
+   under `spec/fixtures/level1/constructors/`. This is the format catalog Level 2
+   (deserialization) and Level 3 (API logic) tests work against.
+2. **Test cases**: one user-facing scenario per executable script under `spec/level1/`,
+   producing a folder of fixtures under `spec/fixtures/level1/test_cases/<scenario>/`.
+   A test case captures whatever Telegram actually sends end-to-end during that
+   scenario.
+
+The set of test cases is chosen so that, taken together, they cover every variant
+of every constructor we need to characterize — not so that they reproduce every
+possible user-facing scenario. The same constructor can show up in many test cases
+and inside different parent constructors; we only need to see each variant at least
+once.
+
+## How It Works
+
+These are semi-manual tests. Each test case:
+
+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
+4. Saves the raw decrypted message bodies as `.bin` files and a `captured.json`
+   listing the TL constructors received
+
+On subsequent runs, the freshly captured constructor list is compared to the
+previously stored `captured.json` for the same test case. If they differ, the
+script prints a `CHANGED` warning — usually a signal that Telegram's wire-level
+behavior shifted and the fixtures need to be re-examined.
+
+## Example Scenarios
+
+The list below illustrates the kinds of situations these tests cover.
+It is not exhaustive — new scenarios are added as needed.
+
+- Text message in private chat
+- Text message in a group
+- Text message in a channel
+- Reply to a message
+- Forwarded message
+- Message with photo
+- Message with document
+- Message in a forum topic
+- User joined a group
+- User left a group
+- Message edited
+- Message deleted
+
+## Fixture Layout
+
+```
+spec/fixtures/level1/
+  test_cases/
+    receive_private_text_message/
+      001.bin
+      002.bin
+      003.bin
+      004.bin
+      captured.json
+    receive_group_text_message/
+      001.bin
+      002.bin
+      captured.json
+    ...
+  constructors/
+    updateShortMessage/
+      plain_in.bin
+      with_fwd_from.bin
+      with_reply_to.bin
+      with_entities_bold.bin
+      ...
+    messageFwdHeader/
+      from_user.bin
+      from_channel.bin
+      ...
+    messageEntity/
+      bold.bin
+      italic.bin
+      url.bin
+      ...
+    ...
+```
+
+Each test case produces:
+
+- One or more `.bin` files with raw decrypted message bodies, numbered sequentially
+  in arrival order (one user action may trigger multiple messages from Telegram).
+- A `captured.json` listing each captured message as an object with two fields —
+  the TL `constructor` name and the `file` containing its raw body bytes.
+
+Shape of `captured.json`:
+
+```json
+[
+  { "constructor": "msgs_ack",           "file": "001.bin" },
+  { "constructor": "updateShort",        "file": "002.bin" },
+  { "constructor": "updateShortMessage", "file": "003.bin" }
+]
+```
+
+The `constructors/` tree is a separate, deduplicated library populated from
+test-case captures: one `.bin` per distinct variant of each constructor, with
+the filename describing the variant (e.g. `plain_in.bin`, `with_fwd_from.bin`).
+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`.
+
+```
+spec/
+  level1/
+    support/                       # Shared test infrastructure
+    receive_private_text_message   # Executable script (one per test case)
+    receive_group_text_message
+    ...
+  fixtures/
+    level1/
+      test_cases/                  # Per-test-case captures (folder per scenario)
+      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
+
+```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'
+```
+
+`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.
+```
+
+### 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
+```
+
+That noise lands on stderr, which the daemon inherits and writes into
+`/tmp/xp-daemon.log`. The script's own stdout stays clean.

data/lib/mtproto/auth_key_generator.rb

@@ -86,13 +86,13 @@ module MTProto
     private
 
     def send_and_receive(rpc, response_class)
-      message = Message.new(rpc.body)
+      message = Message.new(rpc.serialize)
       @connection.send(Transport::Packet.new(message.bytes))
 
       response_packet = @connection.receive
       raise 'Receive timeout' if response_packet.nil?
 
-      result = response_class.parse(Message.parse(response_packet))
+      result = response_class.deserialize(Message.parse(response_packet))
 
       raise 'Nonce mismatch!' if rpc.respond_to?(:nonce) && result.nonce != rpc.nonce
       raise 'Server nonce mismatch!' if rpc.respond_to?(:server_nonce) && result.server_nonce != rpc.server_nonce
@@ -114,7 +114,7 @@ module MTProto
         new_nonce: new_nonce,
         dc: dc_value
       )
-      encrypted_data = Crypto::RSA_PAD.encrypt(inner_data.body.pack('C*'), server_key)
+      encrypted_data = Crypto::RSA_PAD.encrypt(inner_data.serialize.pack('C*'), server_key)
 
       rpc = TL::ReqDHParams.new(
         nonce: res_pq.nonce,
@@ -149,7 +149,7 @@ module MTProto
         answer = answer[0..-2]
       end
 
-      TL::ServerDHInnerData.parse(answer)
+      TL::ServerDHInnerData.deserialize(answer)
     end
 
     def send_client_dh_params(res_pq, _new_nonce, client_dh_params, tmp_aes_key, tmp_aes_iv)
@@ -160,7 +160,7 @@ module MTProto
         g_b: client_dh_params[:g_b_bytes]
       )
 
-      client_dh_data = client_dh_inner_data.body.pack('C*')
+      client_dh_data = client_dh_inner_data.serialize.pack('C*')
       client_dh_data_with_hash = Digest::SHA1.digest(client_dh_data) + client_dh_data
 
       padding_length = (16 - (client_dh_data_with_hash.bytesize % 16)) % 16

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_contacts'
+require_relative '../../tl/objects/contacts'
+
+module MTProto
+  class Client
+    class API
+      def get_contacts(hash: 0)
+        rpc_call(TL::GetContacts.new(hash: hash), TL::Contacts).body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/send_message'
+require_relative '../../tl/objects/update_short_sent_message'
+
+module MTProto
+  class Client
+    class API
+      def send_message(peer:, message:, random_id: nil)
+        rpc_call(TL::SendMessage.new(peer: peer, message: message, random_id: random_id),
+                 TL::UpdateShortSentMessage).body
+      end
+    end
+  end
+end

data/lib/mtproto/client/api.rb

@@ -10,6 +10,8 @@ require_relative 'api/get_dialogs'
 require_relative 'api/get_history'
 require_relative 'api/get_updates_state'
 require_relative 'api/get_updates_difference'
+require_relative 'api/send_message'
+require_relative 'api/get_contacts'
 
 module MTProto
   class Client

data/lib/mtproto/client/rpc/response.rb

@@ -43,7 +43,7 @@ module MTProto
         end
 
         def signal(raw_body)
-          @result = @response_class.parse(raw_body)
+          @result = @response_class.deserialize(raw_body)
           @condition.signal
         end
 

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,11 +71,39 @@ 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)
-        if request.respond_to?(:body)
-          request.body.pack('C*')
+        if request.respond_to?(:serialize)
+          request.serialize.pack('C*')
         else
           request
         end

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
@@ -92,24 +99,7 @@ module MTProto
 
       begin
         Async do
-          @running = true
-          @receiver_task = Async do
-            @connection.receive do |packet, error|
-              if error
-                warn "[MTProto] Packet read error: #{error.message}"
-                next
-              end
-
-              decrypted = EncryptedMessage.decrypt(
-                auth_key: @auth_key,
-                encrypted_message_data: packet.data.pack('C*'),
-                sender: :server
-              )
-
-              process_message(decrypted[:body])
-            end
-          end
-
+          start_receiving!
           yield self
         ensure
           disconnect!
@@ -119,10 +109,43 @@ module MTProto
       end
     end
 
+    # Start the receiver task without taking over the current Async reactor.
+    # Use when orchestrating multiple clients in a shared Async block — call
+    # from inside an Async do ... end. The caller is responsible for
+    # disconnect! at the end.
+    def start_receiving!
+      raise 'Auth key not set' unless auth_key?
+      raise 'Mainloop already running' if @running
+
+      @running = true
+      @ack_ids = []
+      @receiver_task = Async do
+        @connection.receive do |packet, error|
+          if error
+            warn "[MTProto] Packet read error: #{error.message}"
+            next
+          end
+
+          decrypted = EncryptedMessage.decrypt(
+            auth_key: @auth_key,
+            encrypted_message_data: packet.data.pack('C*'),
+            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'))
 
@@ -222,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/constructors.rb

@@ -19,6 +19,7 @@ module MTProto
       PEER_CHAT = 0x36c6019a
       PEER_CHANNEL = 0xa2a5371e
       INPUT_PEER_EMPTY = 0x7f3b18ea
+      INPUT_PEER_SELF = 0x7da07ec9
       INPUT_PEER_USER = 0xdde8a54c
       INPUT_PEER_CHAT = 0x35a95cb9
       INPUT_PEER_CHANNEL = 0x27bcbbfc
@@ -71,9 +72,24 @@ module MTProto
       USERS_GET_USERS = 0x0d91a548
       USER = 0x020b1422
 
+      # Contacts
+      CONTACTS_GET_CONTACTS = 0x5dd69e12
+      CONTACTS_CONTACTS = 0xeae87e42
+      CONTACTS_CONTACTS_NOT_MODIFIED = 0xb74ba9d2
+      CONTACT = 0x145ade0b
+
       # Messages
       MESSAGES_GET_DIALOGS = 0xa0f4cb4f
       MESSAGES_GET_HISTORY = 0x4423e6c5
+      MESSAGES_SEND_MESSAGE = 0xfe05dc9a
+      MESSAGES_SEND_MEDIA = 0xac55d9c1
+      MESSAGES_EDIT_MESSAGE = 0xdfd14005
+      MESSAGES_DELETE_MESSAGES = 0xe58e95d2
+
+      # Upload + media
+      UPLOAD_SAVE_FILE_PART = 0xb304a621
+      INPUT_FILE = 0xf52ff27f
+      INPUT_MEDIA_UPLOADED_PHOTO = 0x1e287d04
       MESSAGES_DIALOGS = 0x15ba6c40
       MESSAGES_DIALOGS_SLICE = 0x71e094f3
       MESSAGE = 0x9815cec8
@@ -87,6 +103,16 @@ module MTProto
       UPDATE_NEW_MESSAGE = 0x1f2b0afd
       UPDATE_SHORT = 0x78d4dec1
       UPDATE_SHORT_MESSAGE = 0x313bc7f8
+      UPDATE_SHORT_SENT_MESSAGE = 0x9015e101
+
+      # Channel updates
+      INPUT_CHANNEL = 0xf35aec28
+      INPUT_CHANNEL_EMPTY = 0xee8c1e86
+      CHANNEL_MESSAGES_FILTER_EMPTY = 0x94d42ee7
+      UPDATES_GET_CHANNEL_DIFFERENCE = 0x03173d78
+      UPDATES_CHANNEL_DIFFERENCE = 0x2064674e
+      UPDATES_CHANNEL_DIFFERENCE_EMPTY = 0x3e11affb
+      UPDATES_CHANNEL_DIFFERENCE_TOO_LONG = 0xa4bcc6fe
       UPDATES_GET_STATE = 0xedd4882a
       UPDATES_STATE = 0xa56c2a3e
       UPDATES_GET_DIFFERENCE = 0x19c2f763

data/lib/mtproto/tl/object.rb

@@ -12,7 +12,7 @@ module MTProto
         @payload = payload
       end
 
-      def self.parse(message)
+      def self.deserialize(message)
         body = message.body
         constructor_id = b_u32(body[0, 4])
         constructor = ConstructorNames::NAMES.fetch(constructor_id)

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

@@ -12,7 +12,7 @@ module MTProto
         @srp_id = srp_id
       end
 
-      def self.parse(data)
+      def self.deserialize(data)
         constructor = data[0, 4].unpack1('L<')
         raise UnexpectedConstructorError, constructor unless constructor == Constructors::ACCOUNT_PASSWORD