mtproto 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b96860172330495c1d12e06b8de8861ac33c97a6882a955fc77fe3e85e4268e4
-  data.tar.gz: 95c1faa866ea16ad23ba0cc06849adb6684f2267a53f7f018dc2ade8ad8decb4
+  metadata.gz: 9c0529af4d0277b14c02e0a618a865e67234aaf956873d749579f0aae5d2b4c8
+  data.tar.gz: c519588e92e960402dfe515e9b202e8f9c83a05ca6a21952a05d339b031c8878
 SHA512:
-  metadata.gz: 6566d9f51ccf60e24a99ec3410309088813a26dd42fa353699390c2714427e688e43882130e950cfe24268f586ed920ac4b6e7473cb183e660f8be3d4a249191
-  data.tar.gz: 36016eb3d8176d4dc806fa8057835d0b9947ef5ad77acc9e32add81a39a6bb2a2a8a367b5a5329ece094299cfdf2188350658c1b69a42c23d0d34cf576ac6281
+  metadata.gz: 782793b348cdd81fd8bfb43ceedd459bef20c0c2033c5b36068a392db9b3cc796273c0debfe9ddf0a1c2965b6b7aebe4a591f8b6afc35fed180e116c40d24a34
+  data.tar.gz: e2221dcca9e4e15f92b88140ef5eeb523e838a1a88687497e87a0241b2c196f2a6c70b841fbfecca36fccbb2ac6f68fa2be912dbe6cdc94f2c32a7175cec9cc5

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_bot_callback_answer'
+require_relative '../../tl/objects/bot_callback_answer'
+
+module MTProto
+  class Client
+    class API
+      # messages.getBotCallbackAnswer — press the inline callback button carrying
+      # `data` on message `msg_id` in `peer`. The server delivers an
+      # updateBotCallbackQuery to the bot and blocks until the bot answers (or the
+      # ~5s timeout), then returns the bot's botCallbackAnswer. This is the client
+      # half of "bots manage bots": the caller drives another bot's inline keyboard.
+      def get_bot_callback_answer(peer:, msg_id:, data: nil)
+        rpc_call(
+          TL::GetBotCallbackAnswer.new(peer: peer, msg_id: msg_id, data: data),
+          TL::BotCallbackAnswer
+        ).body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/get_channel_difference'
+require_relative '../../tl/objects/channel_difference'
+
+module MTProto
+  class Client
+    class API
+      # updates.getChannelDifference — pull a channel/supergroup's backlog since
+      # `pts` (seed it from the dialog's pts). Returns a parsed ChannelDifference.
+      # `force` re-fetches even without a pending gap.
+      def get_channel_difference(channel:, pts:, limit: 100, force: false)
+        rpc_call(
+          TL::GetChannelDifference.new(
+            channel: channel, pts: pts, limit: limit, force: force
+          ),
+          TL::ChannelDifference
+        ).body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../tl/objects/import_bot_authorization'
+require_relative '../../tl/objects/authorization'
+
+module MTProto
+  class Client
+    class API
+      def import_bot_authorization(bot_auth_token)
+        result = rpc_call(
+          TL::ImportBotAuthorization.new(
+            api_id: @client.api_id,
+            api_hash: @client.api_hash,
+            bot_auth_token: bot_auth_token
+          ),
+          TL::Authorization
+        ).body
+
+        if result.authorization? && result.user_id
+          @client.update_user(user_id: result.user_id, access_hash: result.access_hash)
+        end
+
+        result
+      end
+    end
+  end
+end

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

@@ -2,13 +2,28 @@
 
 require_relative '../../tl/objects/send_message'
 require_relative '../../tl/objects/update_short_sent_message'
+require_relative '../../markdown'
 
 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
+      # Send a text message. Formatting can be supplied three ways:
+      #   - `entities:` — explicit formatting spans;
+      #   - `parse_mode: :markdown` — parse Markdown out of `message` on the client
+      #     (the plain text + derived entities are sent);
+      #   - `rich_markdown:` — Telegram's server-side "Rich Formatting": the raw
+      #     Markdown string is sent as inputRichMessageMarkdown and the SERVER formats
+      #     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.
+      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)
+        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),
+          TL::UpdateShortSentMessage
+        ).body
       end
     end
   end

data/lib/mtproto/client/api.rb

@@ -4,6 +4,7 @@ require_relative 'api/send_code'
 require_relative 'api/sign_in'
 require_relative 'api/export_authorization'
 require_relative 'api/import_authorization'
+require_relative 'api/import_bot_authorization'
 require_relative 'api/export_login_token'
 require_relative 'api/import_login_token'
 require_relative 'api/check_password'
@@ -12,6 +13,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/get_channel_difference'
+require_relative 'api/get_bot_callback_answer'
 require_relative 'api/send_message'
 require_relative 'api/get_contacts'
 
@@ -25,15 +28,24 @@ module MTProto
       private
 
       def rpc_call(request, response_class)
-        response = @client.rpc.call(request, response_class)
-        response.wait!(@client.timeout)
-        response
-      rescue RpcError => e
-        raise unless e.flood_wait?
-
-        warn "[MTProto] FLOOD_WAIT: retrying in #{e.flood_wait_seconds}s..."
-        sleep(e.flood_wait_seconds)
-        retry
+        reinited = false
+        begin
+          response = @client.rpc.call(request, response_class)
+          response.wait!(@client.timeout)
+          response
+        rescue RpcError => e
+          if e.flood_wait?
+            warn "[MTProto] FLOOD_WAIT: retrying in #{e.flood_wait_seconds}s..."
+            sleep(e.flood_wait_seconds)
+            retry
+          elsif e.error_message == 'CONNECTION_NOT_INITED' && !reinited
+            reinited = true
+            @client.reinit_connection!
+            retry
+          else
+            raise
+          end
+        end
       end
     end
   end

data/lib/mtproto/client/rpc.rb

@@ -36,8 +36,14 @@ module MTProto
         new_server_salt = response_body[20, 8].unpack1('Q<')
 
         client.update_server_salt(new_server_salt)
+        resend(bad_msg_id)
+      end
 
-        response = @pending_requests.delete(bad_msg_id)
+      # Re-send an already-sent request (still tracked in @pending_requests) under
+      # a fresh msg_id, keeping the same Response so its caller's wait! resolves on
+      # the new reply. Used after bad_server_salt / bad_msg_notification.
+      def resend(msg_id)
+        response = @pending_requests.delete(msg_id)
         return unless response
 
         new_msg_id = send_encrypted(response.body_bytes)
@@ -45,6 +51,12 @@ module MTProto
         @pending_requests[new_msg_id] = response
       end
 
+      # Fail a pending request with an error so its caller stops waiting.
+      def fail_request(msg_id, error)
+        response = @pending_requests.delete(msg_id)
+        response&.signal_error(error)
+      end
+
       def handle_rpc_result(response_body)
         req_msg_id = response_body[4, 8].unpack1('Q<')
         result = response_body[12..]

data/lib/mtproto/client.rb

@@ -5,6 +5,7 @@ require 'digest'
 require 'base64'
 require 'async'
 require 'async/condition'
+require_relative 'tl/constructors'
 require_relative 'transport/tcp_connection'
 require_relative 'transport/connection'
 require_relative 'transport/abridged_packet_codec'
@@ -88,6 +89,11 @@ module MTProto
     ACK_INTERVAL = 5
     PING_INTERVAL = 30
 
+    # Reconnect backoff: wait RECONNECT_BACKOFF_BASE seconds after the first failed
+    # attempt, doubling each retry, capped at RECONNECT_BACKOFF_MAX.
+    RECONNECT_BACKOFF_BASE = 1
+    RECONNECT_BACKOFF_MAX = 30
+
     def on_update(&block)
       @on_update_callbacks << block
     end
@@ -119,23 +125,7 @@ module MTProto
 
       @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
+      @receiver_task = Async { receiver_loop }
       @keepalive_task = Async { keepalive_loop }
     end
 
@@ -205,6 +195,14 @@ module MTProto
       response.body
     end
 
+    # Force a fresh initConnection on the current connection. Used to recover
+    # when the server reports CONNECTION_NOT_INITED (it lost our connection
+    # state): reset the guard and run init again.
+    def reinit_connection!
+      @connection_initialized = false
+      init_connection!
+    end
+
     def save_auth_data
       raise 'Cannot save auth_data: auth_key not set' unless @auth_key
 
@@ -245,22 +243,89 @@ 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!.
+    # Read and dispatch incoming messages for as long as the client runs. On a
+    # transport drop, reconnect and resume; the post-reconnect re-init + replay run
+    # in a child task so this loop can read the responses those calls wait on.
+    def receiver_loop
+      while @running
+        begin
+          @connection.receive { |packet, error| handle_incoming(packet, error) }
+        rescue Transport::ConnectionError => e
+          break unless @running
+
+          reconnect_after(e)
+        end
+      end
+    end
+
+    def handle_incoming(packet, error)
+      if error
+        warn "[MTProto] Packet read error: #{error.message}"
+        return
+      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], decrypted[:msg_id])
+    end
+
+    # Re-establish the transport and re-run initConnection. The re-init runs in a
+    # child task because it waits on a response that only this (resumed) receiver
+    # loop can read.
+    def reconnect_after(error)
+      warn "[MTProto] connection lost (#{error.message}); reconnecting"
+      # Fail in-flight requests instead of resending them across the drop: a
+      # resend could double-execute a side-effecting request, so callers retry at
+      # a higher level. Matches mtproto-rust's reconnect behaviour.
+      rpc.signal_all_error(error)
+      @connection_initialized = false
+      reestablish_connection
+      return unless @running
+
+      Async { init_connection! }
+    end
+
+    # Reconnect the transport, retrying with exponential backoff until it succeeds
+    # or the client is shut down.
+    def reestablish_connection
+      attempt = 0
+      while @running
+        @connection.disconnect!
+        begin
+          @connection.connect!
+          return
+        rescue Transport::ConnectionError, SystemCallError => e
+          attempt += 1
+          warn "[MTProto] reconnect attempt #{attempt} failed: #{e.message}"
+          sleep [RECONNECT_BACKOFF_BASE * (2**(attempt - 1)), RECONNECT_BACKOFF_MAX].min
+        end
+      end
+    end
+
+    # Periodically acknowledge received messages and ping so the server keeps the
+    # connection. Survives transport drops (a failed tick is skipped; the receiver
+    # loop reconnects) and ends when the client is shut down.
     def keepalive_loop
       elapsed = 0
-      loop do
+      while @running
         sleep ACK_INTERVAL
-        flush_acks
         elapsed += ACK_INTERVAL
-        next if elapsed < PING_INTERVAL
 
-        elapsed = 0
-        rpc.send_ping
+        begin
+          flush_acks
+          next if elapsed < PING_INTERVAL
+
+          elapsed = 0
+          rpc.send_ping
+        rescue Transport::ConnectionError
+          nil # connection down/reconnecting — skip this tick
+        end
       end
-    rescue StandardError
-      nil
     end
 
     # Queue msg_ids of received content-related server messages for msgs_ack.
@@ -285,20 +350,50 @@ module MTProto
       rpc.send_ack(ids)
     end
 
-    def process_message(response_body)
+    def process_message(response_body, server_msg_id)
       constructor = response_body[0, 4].unpack1('L<')
 
       case constructor
-      when TL::Constructors::BAD_SERVER_SALT
-        rpc.handle_bad_server_salt(response_body, self)
-      when TL::Constructors::NEW_SESSION_CREATED
-        handle_new_session(response_body)
       when TL::Constructors::MSG_CONTAINER
         handle_container(response_body)
       when TL::Constructors::RPC_RESULT
         rpc.handle_rpc_result(response_body)
+      when TL::Constructors::BAD_SERVER_SALT
+        rpc.handle_bad_server_salt(response_body, self)
+      when TL::Constructors::BAD_MSG_NOTIFICATION
+        handle_bad_msg_notification(response_body, server_msg_id)
+      when TL::Constructors::NEW_SESSION_CREATED
+        handle_new_session(response_body)
+      when *TL::Constructors::SERVICE_MESSAGES
+        nil # transport/service messages — no app-level action
+      else
+        dispatch_update(constructor, response_body)
+      end
+    end
+
+    def dispatch_update(constructor, response_body)
+      unless TL::Constructors::UPDATE_CONSTRUCTORS.include?(constructor)
+        warn "[MTProto] Ignoring unknown server message 0x#{constructor.to_s(16).rjust(8, '0')}"
+        return
+      end
+
+      @on_update_callbacks.each { |cb| cb.call(constructor, response_body) }
+    end
+
+    # bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int error_code:int.
+    # Codes 16/17 mean our clock is off (msg_id too low/high): resync time_offset
+    # from the server msg_id and resend the rejected request. Other codes can't be
+    # auto-recovered here, so fail the request loudly instead of leaving it to hang.
+    def handle_bad_msg_notification(response_body, server_msg_id)
+      bad_msg_id = response_body[4, 8].unpack1('Q<')
+      error_code = response_body[16, 4].unpack1('l<')
+
+      if [16, 17].include?(error_code)
+        @time_offset = (server_msg_id >> 32) - Time.now.to_i
+        rpc.resend(bad_msg_id)
       else
-        @on_update_callbacks.each { |cb| cb.call(constructor, response_body) }
+        warn "[MTProto] bad_msg_notification code=#{error_code} for msg #{bad_msg_id}"
+        rpc.fail_request(bad_msg_id, RpcError.new(0, "BAD_MSG_NOTIFICATION_#{error_code}"))
       end
     end
 
@@ -311,7 +406,7 @@ module MTProto
       container = TL::MsgContainer.deserialize(response_body)
 
       container.messages.each do |msg|
-        process_message(msg[:body])
+        process_message(msg[:body], msg[:msg_id])
       end
     end
   end

data/lib/mtproto/dc.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MTProto
+  # Datacenter IP addresses by number. An auth key is bound to the DC that
+  # issued it, so a saved session must reconnect to that same DC — resolve the
+  # host from auth_data[:dc_number] rather than assuming a single endpoint.
+  module DC
+    PRODUCTION = {
+      1 => '149.154.175.53',
+      2 => '149.154.167.51',
+      3 => '149.154.175.100',
+      4 => '149.154.167.91',
+      5 => '91.108.56.130'
+    }.freeze
+
+    TEST = {
+      1 => '149.154.175.40',
+      2 => '149.154.167.40',
+      3 => '149.154.175.117'
+    }.freeze
+
+    DEFAULT_PORT = 443
+
+    module_function
+
+    def address(dc_number, test:)
+      map = test ? TEST : PRODUCTION
+      { host: map[dc_number] || map.fetch(2), port: DEFAULT_PORT }
+    end
+  end
+end