mtproto 0.0.8 → 0.0.10

data/lib/mtproto/async_client.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-require_relative 'async/request'
-require_relative 'async/request_queue'
-require_relative 'async/middleware/base'
-require_relative 'async/middleware/flood_wait'
-
-module MTProto
-  class AsyncClient
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-      @queue = Async::RequestQueue.new
-      @middleware_classes = []
-      @pending_requests = Concurrent::Hash.new
-      @timeout_threads = Concurrent::Hash.new
-      @receiver_thread = nil
-      @running = Concurrent::AtomicBoolean.new(false)
-
-      use(Async::Middleware::FloodWait)
-    end
-
-    def use(middleware_class, **options)
-      @middleware_classes << [middleware_class, options]
-      self
-    end
-
-    def call(body, metadata: {})
-      ensure_receiver_running!
-
-      request = Async::Request.new(body: body, metadata: metadata)
-
-      @queue.call(key: request.key) do
-        send_and_wrap = lambda do |retries = 0|
-          base_future = send_request(request.body)
-
-          retry_fn = lambda do
-            send_and_wrap.call(retries + 1)
-          end
-
-          build_middleware_stack.call(request, base_future, retry_fn, retries)
-        end
-
-        send_and_wrap.call(0)
-      end
-    end
-
-    def shutdown
-      @running.make_false
-
-      @client.disconnect! if @client.connected?
-
-      if @receiver_thread
-        @receiver_thread.join(2)
-        @receiver_thread.kill if @receiver_thread.alive?
-        @receiver_thread = nil
-      end
-
-      @timeout_threads.each_value(&:kill)
-      @timeout_threads.clear
-
-      @pending_requests.each_value do |future|
-        future.reject(MTProto::Transport::ConnectionError.new('Client shutting down')) unless future.resolved?
-      end
-      @pending_requests.clear
-
-      @queue.shutdown
-    end
-
-    private
-
-    def send_request(body)
-      msg_id = @client.rpc.call(body)
-      future = Concurrent::Promises.resolvable_future
-      @pending_requests[msg_id] = future
-
-      timeout_thread = Thread.new do
-        sleep @client.timeout
-        if @pending_requests.delete(msg_id)
-          future.reject(MTProto::Transport::ConnectionError.new('RPC timeout'))
-        end
-        @timeout_threads.delete(msg_id)
-      end
-      @timeout_threads[msg_id] = timeout_thread
-
-      future.on_fulfillment! do
-        timeout_thread.kill
-        @timeout_threads.delete(msg_id)
-      end
-      future.on_rejection! do
-        timeout_thread.kill
-        @timeout_threads.delete(msg_id)
-      end
-
-      future
-    end
-
-    def ensure_receiver_running!
-      return if @running.true?
-
-      @running.make_true
-      @receiver_thread = Thread.new { receiver_loop }
-    end
-
-    def receiver_loop
-      loop do
-        break unless @running.true?
-
-        begin
-          response_data = @client.connection.recv(timeout: 1)
-
-          decrypted = EncryptedMessage.decrypt(
-            auth_key: @client.auth_key,
-            encrypted_message_data: response_data,
-            sender: :server
-          )
-
-          process_message(decrypted[:body])
-        rescue MTProto::Transport::ConnectionError => e
-          next if e.message == 'Receive timeout' && @running.true?
-          break
-        rescue IOError => e
-          break
-        rescue => e
-          warn "AsyncClient receiver error: #{e.class}: #{e.message}"
-          warn e.backtrace.join("\n")
-          break
-        end
-      end
-    end
-
-    def process_message(response_body)
-      constructor = response_body[0, 4].unpack1('L<')
-
-      case constructor
-      when Client::RPC::CONSTRUCTOR_BAD_SERVER_SALT
-        handle_bad_server_salt(response_body)
-      when Type::NewSessionCreated::CONSTRUCTOR
-        handle_new_session(response_body)
-      when Type::MsgContainer::CONSTRUCTOR
-        handle_container(response_body)
-      when Client::RPC::CONSTRUCTOR_RPC_RESULT
-        handle_rpc_result(response_body)
-      end
-    end
-
-    def handle_bad_server_salt(response_body)
-      offset = 4
-      offset += 8
-      offset += 4
-      offset += 4
-      new_server_salt = response_body[offset, 8].unpack1('Q<')
-
-      @client.instance_variable_set(:@server_salt, new_server_salt)
-    end
-
-    def handle_new_session(response_body)
-      session_info = Type::NewSessionCreated.deserialize(response_body)
-      @client.instance_variable_set(:@server_salt, session_info.server_salt)
-    end
-
-    def handle_container(response_body)
-      container = Type::MsgContainer.deserialize(response_body)
-
-      container.messages.each do |msg|
-        process_message(msg[:body])
-      end
-    end
-
-    def handle_rpc_result(response_body)
-      offset = 4
-      req_msg_id = response_body[offset, 8].unpack1('Q<')
-      offset += 8
-      result = response_body[offset..]
-
-      future = @pending_requests.delete(req_msg_id)
-      return unless future  # No pending request for this msg_id
-
-      # Check if result is an RPC error
-      result_constructor = result[0, 4].unpack1('L<')
-      if result_constructor == Type::RpcError::CONSTRUCTOR
-        error = Type::RpcError.deserialize(result)
-        future.reject(MTProto::RpcError.new(error.error_code, error.error_message))
-      else
-        future.fulfill(result)
-      end
-    end
-
-    def build_middleware_stack
-      # Middleware now wraps Futures and can trigger retries
-      # The base "app" just returns the Future as-is
-      app = ->(request, future, retry_fn, retries) { future }
-
-      @middleware_classes.reverse.reduce(app) do |stack, (middleware_class, options)|
-        middleware_class.new(stack, **options)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_config.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/help/get_config'
-require_relative '../type/rpc/help/config'
-
-module MTProto
-  module RPC
-    class GetConfig
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        query = build_query
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        query = build_query
-
-        response = @client.rpc.call_sync(query)
-
-        Type::RPC::Help::Config.parse(response)
-      end
-
-      private
-
-      def build_query
-        Type::RPC::Help::GetConfig.build
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_contacts.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/contacts/get_contacts'
-require_relative '../type/rpc/contacts/contacts'
-
-module MTProto
-  module RPC
-    class GetContacts
-      def initialize(client)
-        @client = client
-      end
-
-      def call(hash: 0)
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
-        @client.rpc.call(query)
-      end
-
-      def call_sync(hash: 0)
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Contacts::GetContacts.build(hash: hash)
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Contacts::Contacts.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_updates_difference.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/updates/get_difference'
-require_relative '../type/rpc/updates/difference'
-
-module MTProto
-  module RPC
-    class GetUpdatesDifference
-      def initialize(client)
-        @client = client
-      end
-
-      def call(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'pts is required' if pts.nil?
-        raise ArgumentError, 'date is required' if date.nil?
-        raise ArgumentError, 'qts is required' if qts.nil?
-
-        query = Type::RPC::Updates::GetDifference.build(
-          pts: pts,
-          pts_limit: pts_limit,
-          pts_total_limit: pts_total_limit,
-          date: date,
-          qts: qts,
-          qts_limit: qts_limit
-        )
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(pts:, date:, qts:, pts_limit: 100, qts_limit: 100, pts_total_limit: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'pts is required' if pts.nil?
-        raise ArgumentError, 'date is required' if date.nil?
-        raise ArgumentError, 'qts is required' if qts.nil?
-
-        query = Type::RPC::Updates::GetDifference.build(
-          pts: pts,
-          pts_limit: pts_limit,
-          pts_total_limit: pts_total_limit,
-          date: date,
-          qts: qts,
-          qts_limit: qts_limit
-        )
-
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Updates::Difference.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_updates_state.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/updates/get_state'
-require_relative '../type/rpc/updates/state'
-
-module MTProto
-  module RPC
-    class GetUpdatesState
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Updates::GetState.build
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Updates::GetState.build
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Updates::State.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/get_users.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/users/get_users'
-require_relative '../type/rpc/users/users'
-
-module MTProto
-  module RPC
-    class GetUsers
-      def initialize(client)
-        @client = client
-      end
-
-      def call
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Users::GetUsers.build
-        @client.rpc.call(query)
-      end
-
-      def call_sync
-        raise 'Auth key not generated' unless @client.auth_key
-
-        query = Type::RPC::Users::GetUsers.build
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Users::Users.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/ping.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/ping'
-require_relative '../type/rpc/pong'
-
-module MTProto
-  module RPC
-    class Ping
-      def initialize(client)
-        @client = client
-      end
-
-      def call(ping_id = nil)
-        ping_id ||= rand(2**63)
-        body = Type::RPC::Ping.build(ping_id)
-
-        @client.rpc.call(body)
-      end
-
-      def call_sync(ping_id = nil)
-        ping_id ||= rand(2**63)
-        body = Type::RPC::Ping.build(ping_id)
-
-        response_body = @client.rpc.call_sync(body)
-        pong = Type::RPC::Pong.parse(response_body)
-
-        raise PingMismatchError unless pong[:ping_id] == ping_id
-
-        true
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/send_code.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/auth/send_code'
-require_relative '../type/rpc/auth/sent_code'
-
-module MTProto
-  module RPC
-    class SendCode
-      def initialize(client)
-        @client = client
-      end
-
-      def call(phone_number, code_settings: {})
-        query = build_query(phone_number, code_settings)
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(phone_number, code_settings: {})
-        query = build_query(phone_number, code_settings)
-
-        response = @client.rpc.call_sync(query)
-
-        Type::RPC::Auth::SentCode.parse(response)
-      end
-
-      private
-
-      def build_query(phone_number, code_settings)
-        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
-
-        Type::RPC::Auth::SendCode.build(
-          phone_number: phone_number,
-          api_id: @client.api_id,
-          api_hash: @client.api_hash,
-          code_settings: code_settings
-        )
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/send_message.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/messages/send_message'
-require_relative '../type/rpc/messages/updates'
-
-module MTProto
-  module RPC
-    class SendMessage
-      def initialize(client)
-        @client = client
-      end
-
-      def call(user_id:, access_hash:, message:, random_id: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'user_id is required' if user_id.nil?
-        raise ArgumentError, 'access_hash is required' if access_hash.nil?
-        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
-
-        query = Type::RPC::Messages::SendMessage.build(
-          user_id: user_id,
-          access_hash: access_hash,
-          message: message,
-          random_id: random_id
-        )
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(user_id:, access_hash:, message:, random_id: nil)
-        raise 'Auth key not generated' unless @client.auth_key
-        raise ArgumentError, 'user_id is required' if user_id.nil?
-        raise ArgumentError, 'access_hash is required' if access_hash.nil?
-        raise ArgumentError, 'message is required and cannot be empty' if message.nil? || message.empty?
-
-        query = Type::RPC::Messages::SendMessage.build(
-          user_id: user_id,
-          access_hash: access_hash,
-          message: message,
-          random_id: random_id
-        )
-
-        response = @client.rpc.call_sync(query)
-        Type::RPC::Messages::Updates.parse(response)
-      end
-    end
-  end
-end

data/lib/mtproto/rpc/sign_in.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../type/rpc/auth/sign_in'
-require_relative '../type/rpc/auth/authorization'
-
-module MTProto
-  module RPC
-    class SignIn
-      def initialize(client)
-        @client = client
-      end
-
-      def call(phone_number:, phone_code_hash:, phone_code:)
-        query = build_query(phone_number, phone_code_hash, phone_code)
-
-        @client.rpc.call(query)
-      end
-
-      def call_sync(phone_number:, phone_code_hash:, phone_code:)
-        query = build_query(phone_number, phone_code_hash, phone_code)
-
-        response = @client.rpc.call_sync(query)
-
-        result = Type::RPC::Auth::Authorization.parse(response)
-
-        if result[:authorization] && result[:user_id]
-          @client.update_user(user_id: result[:user_id], access_hash: result[:access_hash])
-        end
-
-        result
-      end
-
-      private
-
-      def build_query(phone_number, phone_code_hash, phone_code)
-        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
-        raise ArgumentError, 'phone_code_hash is required' if phone_code_hash.nil? || phone_code_hash.empty?
-        raise ArgumentError, 'phone_code is required' if phone_code.nil? || phone_code.empty?
-
-        Type::RPC::Auth::SignIn.build(
-          phone_number: phone_number,
-          phone_code_hash: phone_code_hash,
-          phone_code: phone_code
-        )
-      end
-    end
-  end
-end

data/lib/mtproto/type/auth_key/dh_gen_response.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module AuthKey
-      class DHGenResponse
-        CONSTRUCTOR_DH_GEN_OK = 0x3bcbf734
-        CONSTRUCTOR_DH_GEN_RETRY = 0x46dc1fb9
-        CONSTRUCTOR_DH_GEN_FAIL = 0xa69dae02
-
-        def self.parse(body)
-          constructor = body[0, 4].unpack1('L<')
-
-          offset = 4
-          nonce = body[offset, 16]
-          offset += 16
-
-          server_nonce = body[offset, 16]
-          offset += 16
-
-          new_nonce_hash = body[offset, 16]
-
-          case constructor
-          when CONSTRUCTOR_DH_GEN_OK
-            { status: :ok, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
-          when CONSTRUCTOR_DH_GEN_RETRY
-            { status: :retry, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
-          when CONSTRUCTOR_DH_GEN_FAIL
-            { status: :fail, nonce: nonce, server_nonce: server_nonce, new_nonce_hash: new_nonce_hash }
-          else
-            raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/auth_key/req_dh_params.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../serializer'
-
-module MTProto
-  module Type
-    module AuthKey
-      class ReqDHParams
-        CONSTRUCTOR = 0xd712e4be
-
-        def self.build(nonce:, server_nonce:, p:, q:, public_key_fingerprint:, encrypted_data:)
-          raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
-          raise ArgumentError, 'Server nonce must be 16 bytes' unless server_nonce.bytesize == 16
-
-          p_bytes = Serializer.integer_to_bytes(p)
-          q_bytes = Serializer.integer_to_bytes(q)
-
-          body = Serializer.serialize_int(CONSTRUCTOR)
-          body += nonce
-          body += server_nonce
-          body += Serializer.serialize_bytes(p_bytes)
-          body += Serializer.serialize_bytes(q_bytes)
-          body += Serializer.serialize_long(public_key_fingerprint)
-          body += Serializer.serialize_bytes(encrypted_data)
-
-          body
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/auth_key/req_pq_multi.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module AuthKey
-      class ReqPqMulti
-        CONSTRUCTOR = 0xbe7e8ef1
-
-        def self.build(nonce)
-          raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
-
-          constructor = [CONSTRUCTOR].pack('L<')
-          constructor + nonce
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/auth_key/res_pq.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module AuthKey
-      class ResPq
-        CONSTRUCTOR = 0x05162463
-
-        def self.parse(body)
-          constructor = body[0, 4].unpack1('L<')
-          raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
-
-          offset = 4
-
-          nonce = body[offset, 16]
-          offset += 16
-
-          server_nonce = body[offset, 16]
-          offset += 16
-
-          pq_length_byte = body[offset].unpack1('C')
-          offset += 1
-
-          pq_length = if pq_length_byte == 254
-            body[offset, 3].unpack1('L<') & 0xffffff
-            offset += 3
-          else
-            pq_length_byte
-          end
-
-          pq = body[offset, pq_length]
-          offset += pq_length
-          offset += padding_length(pq_length + 1)
-
-          vector_constructor = body[offset, 4].unpack1('L<')
-          offset += 4
-          raise 'Expected vector constructor' unless vector_constructor == 0x1cb5c415
-
-          fingerprints_count = body[offset, 4].unpack1('L<')
-          offset += 4
-
-          fingerprints = []
-          fingerprints_count.times do
-            fingerprints << body[offset, 8].unpack1('Q<')
-            offset += 8
-          end
-
-          {
-            nonce: nonce,
-            server_nonce: server_nonce,
-            pq: pq,
-            fingerprints: fingerprints
-          }
-        end
-
-        def self.padding_length(length)
-          (4 - (length % 4)) % 4
-        end
-      end
-    end
-  end
-end