mtproto 0.0.5 → 0.0.7

data/lib/mtproto/errors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MTProto
+  class Error < StandardError; end
+
+  class NotConnectedError < Error
+    def initialize(msg = 'Not connected. Call connect first.')
+      super
+    end
+  end
+
+  class PingMismatchError < Error
+    def initialize(msg = 'Ping ID mismatch')
+      super
+    end
+  end
+
+  class RpcError < Error
+    attr_reader :error_code, :error_message
+
+    def initialize(error_code, error_message)
+      @error_code = error_code
+      @error_message = error_message
+      super("RPC Error #{error_code}: #{error_message}")
+    end
+  end
+
+  class UnexpectedConstructorError < Error
+    def initialize(constructor)
+      super("Unexpected constructor: 0x#{constructor.to_s(16)}")
+    end
+  end
+end

data/lib/mtproto/message_id.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MTProto
+  module MessageId
+    module_function
+
+    def generate(time_offset: 0)
+      time = Time.now.to_f + time_offset
+      msg_id = (time * (2**32)).to_i
+      (msg_id / 4) * 4
+    end
+  end
+end

data/lib/mtproto/rpc/get_config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/help/get_config'
+require_relative '../tl/rpc/help/config'
+
+module MTProto
+  module RPC
+    class GetConfig
+      def initialize(client)
+        @client = client
+      end
+
+      def call
+        query = TL::RPC::Help::GetConfig.build
+
+        unless @client.instance_variable_get(:@connection_initialized)
+          query = @client.init_connection(
+            api_id: @client.api_id,
+            device_model: @client.device_model,
+            system_version: @client.system_version,
+            app_version: @client.app_version,
+            system_lang_code: @client.system_lang_code,
+            lang_pack: @client.lang_pack,
+            lang_code: @client.lang_code,
+            query: query
+          )
+          query = @client.invoke_with_layer(214, query)
+          @client.instance_variable_set(:@connection_initialized, true)
+        end
+
+        response = @client.rpc.call(query)
+
+        TL::RPC::Help::Config.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_contacts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/contacts/get_contacts'
+require_relative '../tl/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 = TL::RPC::Contacts::GetContacts.build(hash: hash)
+        response = @client.rpc.call(query)
+        TL::RPC::Contacts::Contacts.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_difference.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/updates/get_difference'
+require_relative '../tl/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 = TL::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(query)
+        TL::RPC::Updates::Difference.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_updates_state.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/updates/get_state'
+require_relative '../tl/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 = TL::RPC::Updates::GetState.build
+        response = @client.rpc.call(query)
+        TL::RPC::Updates::State.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/get_users.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/users/get_users'
+require_relative '../tl/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 = TL::RPC::Users::GetUsers.build
+        response = @client.rpc.call(query)
+        TL::RPC::Users::Users.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/ping.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/ping'
+require_relative '../tl/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 = TL::RPC::Ping.build(ping_id)
+
+        response_body = @client.rpc.call(body)
+        pong = TL::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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/auth/send_code'
+require_relative '../tl/rpc/auth/sent_code'
+
+module MTProto
+  module RPC
+    class SendCode
+      def initialize(client)
+        @client = client
+      end
+
+      def call(phone_number, code_settings: {})
+        raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+        query = TL::RPC::Auth::SendCode.build(
+          phone_number: phone_number,
+          api_id: @client.api_id,
+          api_hash: @client.api_hash,
+          code_settings: code_settings
+        )
+
+        unless @client.instance_variable_get(:@connection_initialized)
+          query = @client.init_connection(
+            api_id: @client.api_id,
+            device_model: @client.device_model,
+            system_version: @client.system_version,
+            app_version: @client.app_version,
+            system_lang_code: @client.system_lang_code,
+            lang_pack: @client.lang_pack,
+            lang_code: @client.lang_code,
+            query: query
+          )
+          query = @client.invoke_with_layer(214, query)
+          @client.instance_variable_set(:@connection_initialized, true)
+        end
+
+        response = @client.rpc.call(query)
+
+        TL::RPC::Auth::SentCode.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/send_message.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/messages/send_message'
+require_relative '../tl/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 = TL::RPC::Messages::SendMessage.build(
+          user_id: user_id,
+          access_hash: access_hash,
+          message: message,
+          random_id: random_id
+        )
+
+        response = @client.rpc.call(query)
+        TL::RPC::Messages::Updates.parse(response)
+      end
+    end
+  end
+end

data/lib/mtproto/rpc/sign_in.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../tl/rpc/auth/sign_in'
+require_relative '../tl/rpc/auth/authorization'
+
+module MTProto
+  module RPC
+    class SignIn
+      def initialize(client)
+        @client = client
+      end
+
+      def call(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?
+
+        query = TL::RPC::Auth::SignIn.build(
+          phone_number: phone_number,
+          phone_code_hash: phone_code_hash,
+          phone_code: phone_code
+        )
+
+        unless @client.instance_variable_get(:@connection_initialized)
+          query = @client.init_connection(
+            api_id: @client.api_id,
+            device_model: @client.device_model,
+            system_version: @client.system_version,
+            app_version: @client.app_version,
+            system_lang_code: @client.system_lang_code,
+            lang_pack: @client.lang_pack,
+            lang_code: @client.lang_code,
+            query: query
+          )
+          query = @client.invoke_with_layer(214, query)
+          @client.instance_variable_set(:@connection_initialized, true)
+        end
+
+        response = @client.rpc.call(query)
+
+        result = TL::RPC::Auth::Authorization.parse(response)
+
+        # Update client with user data if authorization was successful
+        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/tl/auth_key/dh_gen_response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    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/tl/auth_key/req_dh_params.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module TL
+    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/tl/auth_key/req_pq_multi.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    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/tl/auth_key/res_pq.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    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

data/lib/mtproto/tl/auth_key/server_dh_params.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    module AuthKey
+      class ServerDHParams
+        CONSTRUCTOR = 0xd0e8075c
+
+        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
+
+          length_byte = body[offset].ord
+          offset += 1
+
+          if length_byte == 254
+            length_bytes = body[offset, 3].bytes
+            encrypted_answer_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
+            offset += 3
+          else
+            encrypted_answer_length = length_byte
+          end
+
+          encrypted_answer = body[offset, encrypted_answer_length]
+
+          {
+            nonce: nonce,
+            server_nonce: server_nonce,
+            encrypted_answer: encrypted_answer
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/auth_key/set_client_dh_params.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module TL
+    module AuthKey
+      class SetClientDHParams
+        CONSTRUCTOR = 0xf5045f1f
+
+        def self.build(nonce:, server_nonce:, 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
+
+          body = Serializer.serialize_int(CONSTRUCTOR)
+          body += nonce
+          body += server_nonce
+          body += Serializer.serialize_bytes(encrypted_data)
+
+          body
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/code_settings.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class CodeSettings
+      CONSTRUCTOR = 0xad253d78
+
+      def self.serialize(settings = {})
+        body = Serializer.serialize_int(CONSTRUCTOR)
+
+        flags = 0
+        flags |= (1 << 0) if settings[:allow_flashcall]
+        flags |= (1 << 1) if settings[:current_number]
+        flags |= (1 << 4) if settings[:allow_app_hash]
+        flags |= (1 << 5) if settings[:allow_missed_call]
+        flags |= (1 << 7) if settings[:allow_firebase]
+        flags |= (1 << 9) if settings[:unknown_number]
+
+        body += Serializer.serialize_int(flags)
+
+        body
+      end
+    end
+  end
+end

data/lib/mtproto/tl/config.rb

@@ -10,6 +10,7 @@ module MTProto
 
       def self.deserialize(data)
         offset = 4
+
         flags = data[offset, 4].unpack1('L<')
         offset += 4
 
@@ -28,7 +29,7 @@ module MTProto
         dc_options_constructor = data[offset, 4].unpack1('L<')
         offset += 4
 
-        raise "Expected vector constructor" unless dc_options_constructor == 0x1cb5c415
+        raise "Expected vector constructor 0x1cb5c415, got 0x#{dc_options_constructor.to_s(16)}" unless dc_options_constructor == 0x1cb5c415
 
         dc_options_count = data[offset, 4].unpack1('L<')
         offset += 4
@@ -65,10 +66,11 @@ module MTProto
 
       def self.deserialize_from(data)
         offset = 0
+
         constructor = data[offset, 4].unpack1('L<')
         offset += 4
 
-        raise "Expected dcOption constructor" unless constructor == 0x18b7a10d
+        raise "Expected dcOption constructor 0x18b7a10d, got 0x#{constructor.to_s(16)}" unless constructor == 0x18b7a10d
 
         flags = data[offset, 4].unpack1('L<')
         offset += 4

data/lib/mtproto/tl/gzip_packed.rb

@@ -34,7 +34,7 @@ module MTProto
         compressed_data = data[offset, length]
         raise "Not enough data: expected #{length}, got #{compressed_data&.bytesize}" if compressed_data.nil? || compressed_data.bytesize < length
 
-        Zlib::GzipReader.new(StringIO.new(compressed_data)).read
+        Zlib::GzipReader.new(StringIO.new(compressed_data)).read.force_encoding(Encoding::BINARY)
       end
     end
   end