mtproto 0.0.6 → 0.0.7

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

@@ -1,28 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'serializer'
-
 module MTProto
   module TL
     class Message
-      CONSTRUCTOR_REQ_PQ_MULTI = 0xbe7e8ef1
-      CONSTRUCTOR_RES_PQ = 0x05162463
-      CONSTRUCTOR_REQ_DH_PARAMS = 0xd712e4be
-      CONSTRUCTOR_SERVER_DH_PARAMS_OK = 0xd0e8075c
-      CONSTRUCTOR_SET_CLIENT_DH_PARAMS = 0xf5045f1f
-      CONSTRUCTOR_DH_GEN_OK = 0x3bcbf734
-      CONSTRUCTOR_DH_GEN_RETRY = 0x46dc1fb9
-      CONSTRUCTOR_DH_GEN_FAIL = 0xa69dae02
-      CONSTRUCTOR_PING = 0x7abe77ec
-      CONSTRUCTOR_PONG = 0x347773c5
-      CONSTRUCTOR_BAD_MSG_NOTIFICATION = 0xa7eff811
-      CONSTRUCTOR_MSG_CONTAINER = 0x73f1f8dc
-
       attr_reader :auth_key_id, :msg_id, :body
 
-      def initialize(auth_key_id: 0, msg_id: nil, body: '')
+      def initialize(auth_key_id:, msg_id:, body:)
         @auth_key_id = auth_key_id
-        @msg_id = msg_id || generate_msg_id
+        @msg_id = msg_id
         @body = body
       end
 
@@ -34,45 +19,6 @@ module MTProto
         auth_key_id_bytes + msg_id_bytes + body_length + @body
       end
 
-      def self.req_pq_multi(nonce)
-        raise ArgumentError, 'Nonce must be 16 bytes' unless nonce.bytesize == 16
-
-        constructor = [CONSTRUCTOR_REQ_PQ_MULTI].pack('L<')
-        body = constructor + nonce
-
-        new(auth_key_id: 0, body: body)
-      end
-
-      def self.req_DH_params(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_REQ_DH_PARAMS)
-        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)
-
-        new(auth_key_id: 0, body: body)
-      end
-
-      def self.set_client_DH_params(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_SET_CLIENT_DH_PARAMS)
-        body += nonce
-        body += server_nonce
-        body += Serializer.serialize_bytes(encrypted_data)
-
-        new(auth_key_id: 0, body: body)
-      end
-
       def self.deserialize(data)
         if data.bytesize < 20
           raise(ArgumentError,
@@ -87,166 +33,6 @@ module MTProto
 
         new(auth_key_id: auth_key_id, msg_id: msg_id, body: body)
       end
-
-      def parse_res_pq
-        constructor = @body[0, 4].unpack1('L<')
-        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_RES_PQ
-
-        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 parse_server_DH_params_ok
-        constructor = @body[0, 4].unpack1('L<')
-        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_SERVER_DH_PARAMS_OK
-
-        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
-
-      def parse_dh_gen_response
-        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
-
-      def self.ping(ping_id)
-        body = Serializer.serialize_int(CONSTRUCTOR_PING)
-        body += [ping_id].pack('Q<')
-
-        body
-      end
-
-      def parse_pong
-        constructor = @body[0, 4].unpack1('L<')
-
-        if constructor == CONSTRUCTOR_BAD_MSG_NOTIFICATION
-          bad_msg = TL::BadMsgNotification.deserialize(@body)
-          raise "Bad message notification: #{bad_msg.error_message} (code: #{bad_msg.error_code}, msg_id: #{bad_msg.bad_msg_id}, seqno: #{bad_msg.bad_msg_seqno})"
-        end
-
-        if constructor == CONSTRUCTOR_MSG_CONTAINER
-          container = TL::MsgContainer.deserialize(@body)
-          pong_message = container.messages.find do |msg|
-            msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR_PONG
-          end
-
-          raise 'No pong message found in container' unless pong_message
-
-          offset = 4
-          msg_id = pong_message[:body][offset, 8].unpack1('Q<')
-          offset += 8
-          ping_id = pong_message[:body][offset, 8].unpack1('Q<')
-
-          return { msg_id: msg_id, ping_id: ping_id }
-        end
-
-        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR_PONG
-
-        offset = 4
-        msg_id = @body[offset, 8].unpack1('Q<')
-        offset += 8
-        ping_id = @body[offset, 8].unpack1('Q<')
-
-        { msg_id: msg_id, ping_id: ping_id }
-      end
-
-      private
-
-      def generate_msg_id
-        time = Time.now.to_f
-        msg_id = (time * (2**32)).to_i
-        (msg_id / 4) * 4
-      end
-
-      def padding_length(length)
-        (4 - (length % 4)) % 4
-      end
-
-      def self.padding_length(length)
-        (4 - (length % 4)) % 4
-      end
     end
   end
 end

data/lib/mtproto/tl/method_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'serializer'
+
+module MTProto
+  module TL
+    module MethodBuilder
+      def invoke_with_layer(layer, query)
+        body = Serializer.serialize_int(0xda9b0d0d)
+        body += Serializer.serialize_int(layer)
+        body + query
+      end
+
+      def init_connection(api_id:, device_model:, system_version:, app_version:, system_lang_code:, lang_pack:, lang_code:, query:)
+        body = Serializer.serialize_int(0xc1cd5ea9)
+        flags = 0
+        body += Serializer.serialize_int(flags)
+        body += Serializer.serialize_int(api_id)
+        body += Serializer.serialize_string(device_model)
+        body += Serializer.serialize_string(system_version)
+        body += Serializer.serialize_string(app_version)
+        body += Serializer.serialize_string(system_lang_code)
+        body += Serializer.serialize_string(lang_pack)
+        body += Serializer.serialize_string(lang_code)
+        body + query
+      end
+    end
+  end
+end