mtproto 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd33fd4bcb039dfffa0a6d2c2193e05fdf306a24c8f34a09b197d8aa45dd9117
-  data.tar.gz: 2061be3cf7378f0b86cff34eae3c34fa025bfdb252f61bc99307489437b9ab63
+  metadata.gz: e7f507f0d6cf42ac479bf224933efca12e7519cd67d7e9d8796ceba14f517960
+  data.tar.gz: 79c5137adfc60752fecb5367c6b90a08e7648f8fc523a95382fe7e755888c439
 SHA512:
-  metadata.gz: cb9c3c9c4d59755b3e4693e475f51295476caaeb932239439ff8e0940484bb8fe0dd3420282fd6d2f807b8da6755737ece84d0bf464bd5554e6190dcdebc3845
-  data.tar.gz: dad6e992b30ca7a7e9a20f9d027bd6436a6b90ab6721a45cb36b8ff3080d4e58633d1d50aa2a54c41568a048e93f7b2b9badc4fd7ad3fd361416a3b428da1b18
+  metadata.gz: 48de4193ba146630f831f690527cefcc0577c1bf56ab32452092e68dd75fa5bf86b294b8578e88e4daa26766c39ef78aa60c1a132e38975d6b01f0c21c508f29
+  data.tar.gz: 46d2ad65c9c1f59ea5f75789fb27008620117ab63877dad711add23cb6d477ad9cea5e5dffb724cc4d1d128a67dd9b75f8db9eddaf8e30a16005c377cb1a7542

data/.env.example

@@ -0,0 +1,5 @@
+TG_API_ID=your_api_id
+TG_API_HASH=your_api_hash
+TG_TEST_DC='111.111.111.111:443'
+TG_TEST_DC_N='1'
+TG_TEST_DC_KEY='DC public key'

data/Rakefile

@@ -14,7 +14,20 @@ end
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:unit') do |t|
+  t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/lib/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:integration') do |t|
+  t.rspec_opts = '--require spec_helper'
+  t.pattern = 'spec/integration/**/*_spec.rb'
 end
 
 task spec: :compile
+task 'spec:unit': :compile
+task 'spec:integration': :compile
 task default: :spec

data/lib/mtproto/auth_key_generator.rb

@@ -5,10 +5,17 @@ require 'digest'
 
 module MTProto
   class AuthKeyGenerator
-    attr_reader :connection, :auth_key, :server_salt, :time_offset
+    attr_reader :connection, :auth_key, :server_salt, :time_offset, :timeout
+
+    def initialize(connection, public_key, dc_number = nil, test_mode: false, timeout: 10)
+      raise ArgumentError, "public_key is required" if public_key.nil? || public_key.empty?
+      raise ArgumentError, "dc_number must be positive. Use test_mode: true for test DCs" if dc_number && dc_number < 0
 
-    def initialize(connection)
       @connection = connection
+      @public_key = public_key
+      @dc_number = dc_number
+      @test_mode = test_mode
+      @timeout = timeout
       @auth_key = nil
       @server_salt = nil
       @time_offset = 0
@@ -76,7 +83,7 @@ module MTProto
       message = TL::Message.req_pq_multi(nonce)
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
       res_pq = response_message.parse_res_pq
 
@@ -86,13 +93,19 @@ module MTProto
     end
 
     def find_server_key(fingerprints)
-      server_key = Crypto::RSAKey.find_by_fingerprint(fingerprints)
+      server_key = Crypto::RSAKey.find_by_fingerprint(fingerprints, @public_key)
       raise 'No matching RSA key found!' unless server_key
 
       server_key
     end
 
     def encrypt_pq_inner_data(res_pq, p, q, server_key, new_nonce)
+      raise ArgumentError, "dc_number is required for auth key generation" if @dc_number.nil?
+
+      # For test DCs, add 10000 to the DC number per MTProto spec
+      # For production DCs, use the DC number as-is
+      dc_value = @test_mode ? (@dc_number + 10000) : @dc_number
+
       inner_data = TL::PQInnerData.new(
         pq: Crypto::Factorization.bytes_to_integer(res_pq[:pq]),
         p: p,
@@ -100,7 +113,7 @@ module MTProto
         nonce: res_pq[:nonce],
         server_nonce: res_pq[:server_nonce],
         new_nonce: new_nonce,
-        dc: @connection.port == 443 ? 2 : 1
+        dc: dc_value
       )
 
       Crypto::RSA_PAD.encrypt(inner_data.serialize, server_key)
@@ -118,7 +131,7 @@ module MTProto
 
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
       server_dh_params = response_message.parse_server_DH_params_ok
 
@@ -186,7 +199,7 @@ module MTProto
 
       @connection.send(message.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
       response_message.parse_dh_gen_response
     end

data/lib/mtproto/client.rb

@@ -8,36 +8,45 @@ require_relative 'tl/message'
 
 module MTProto
   class Client
-    DC_ADDRESSES = {
-      1 => ['149.154.175.50', 443],
-      2 => ['149.154.167.51', 443],
-      3 => ['149.154.175.100', 443],
-      4 => ['149.154.167.91', 443],
-      5 => ['91.108.56.130', 443]
-    }.freeze
+    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session, :timeout
+    attr_accessor :api_id, :api_hash, :device_model, :system_version, :app_version, :system_lang_code, :lang_pack, :lang_code
 
-    attr_reader :connection, :server_key, :auth_key, :server_salt, :time_offset, :session
+    CONSTRUCTOR_MSGS_ACK = 0x62d6b459
 
-    def initialize(dc_id: 2)
-      host, port = DC_ADDRESSES[dc_id]
-      raise ArgumentError, "Unknown DC ID: #{dc_id}" unless host
+    def initialize(api_id: nil, api_hash: nil, host:, port: 443, public_key: nil, dc_number: nil, test_mode: false, timeout: 10)
+      raise ArgumentError, "host is required" if host.nil? || host.empty?
+      raise ArgumentError, "dc_number must be positive. Use test_mode: true for test DCs" if dc_number && dc_number < 0
 
       codec = Transport::AbridgedPacketCodec.new
       @connection = Transport::TCPConnection.new(host, port, codec)
+      @public_key = public_key
+      @dc_number = dc_number
+      @test_mode = test_mode
+      @timeout = timeout
       @server_key = nil
       @auth_key = nil
       @server_salt = nil
       @time_offset = 0
       @session = nil
       @connection_initialized = false
+
+      # Client configuration defaults
+      @api_id = api_id || 0
+      @api_hash = api_hash || ''
+      @device_model = 'Ruby MTProto'
+      @system_version = RUBY_DESCRIPTION
+      @app_version = '0.1.0'
+      @system_lang_code = 'en'
+      @lang_pack = ''
+      @lang_code = 'en'
     end
 
-    def connect
-      @connection.connect
+    def connect!
+      @connection.connect!
     end
 
-    def disconnect
-      @connection.close
+    def disconnect!
+      @connection.close if @connection
     end
 
     def req_pq_multi
@@ -48,7 +57,7 @@ module MTProto
 
       @connection.send(payload)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
       response_message = TL::Message.deserialize(response_data)
 
       res_pq = response_message.parse_res_pq
@@ -59,7 +68,9 @@ module MTProto
     end
 
     def make_auth_key
-      generator = AuthKeyGenerator.new(@connection)
+      raise ArgumentError, "public_key is required for auth key generation" if @public_key.nil? || @public_key.empty?
+
+      generator = AuthKeyGenerator.new(@connection, @public_key, @dc_number, test_mode: @test_mode, timeout: @timeout)
       result = generator.generate
 
       @auth_key = generator.auth_key
@@ -94,7 +105,7 @@ module MTProto
 
       @connection.send(encrypted_msg.serialize)
 
-      response_data = @connection.recv(timeout: 10)
+      response_data = @connection.recv(timeout: @timeout)
 
       decrypted = EncryptedMessage.decrypt(
         auth_key: @auth_key,
@@ -105,16 +116,12 @@ module MTProto
       response_body = decrypted[:body]
 
       constructor = response_body[0, 4].unpack1('L<')
-      puts "  [RPC] First response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
 
       if constructor == TL::NewSessionCreated::CONSTRUCTOR
-        puts "  [RPC] Got new_session_created, waiting for actual response..."
         session_info = TL::NewSessionCreated.deserialize(response_body)
         @server_salt = session_info.server_salt
-        puts "  [RPC] Updated server_salt to: 0x#{@server_salt.to_s(16)}"
 
-        response_data = @connection.recv(timeout: 10)
-        puts "  [RPC] Second response received (#{response_data.bytesize} bytes encrypted)"
+        response_data = @connection.recv(timeout: @timeout)
         decrypted = EncryptedMessage.decrypt(
           auth_key: @auth_key,
           encrypted_message_data: response_data,
@@ -122,37 +129,32 @@ module MTProto
         )
         response_body = decrypted[:body]
         constructor = response_body[0, 4].unpack1('L<')
-        puts "  [RPC] Second response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
       end
 
       if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
-        puts "  [RPC] Response is a container, unpacking..."
         container = TL::MsgContainer.deserialize(response_body)
-        puts "  [RPC] Container has #{container.messages.size} messages"
-
-        container.messages.each_with_index do |msg, i|
-          msg_constructor = msg[:body][0, 4].unpack1('L<')
-          puts "  [RPC]   Message #{i}: constructor=0x#{msg_constructor.to_s(16)}, size=#{msg[:body].bytesize}"
-        end
 
         rpc_result = container.messages.find do |msg|
           msg[:body][0, 4].unpack1('L<') == 0xf35c6d01
         end
 
-        if rpc_result
-          puts "  [RPC] Found rpc_result in container, extracting..."
-          return rpc_result[:body][12..]
-        end
+        return rpc_result[:body][12..] if rpc_result
 
         new_session = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == TL::NewSessionCreated::CONSTRUCTOR }
         if new_session
-          puts "  [RPC] Container has new_session_created, updating salt and waiting for RPC result..."
           session_info = TL::NewSessionCreated.deserialize(new_session[:body])
           @server_salt = session_info.server_salt
-          puts "  [RPC] Updated server_salt to: 0x#{@server_salt.to_s(16)}"
 
-          response_data = @connection.recv(timeout: 10)
-          puts "  [RPC] Next response received (#{response_data.bytesize} bytes encrypted)"
+          other_messages = container.messages.reject do |msg|
+            constructor = msg[:body][0, 4].unpack1('L<')
+            constructor == TL::NewSessionCreated::CONSTRUCTOR || constructor == CONSTRUCTOR_MSGS_ACK
+          end
+
+          if !other_messages.empty?
+            return other_messages.first[:body]
+          end
+
+          response_data = @connection.recv(timeout: @timeout)
           decrypted = EncryptedMessage.decrypt(
             auth_key: @auth_key,
             encrypted_message_data: response_data,
@@ -160,15 +162,10 @@ module MTProto
           )
           response_body = decrypted[:body]
           constructor = response_body[0, 4].unpack1('L<')
-          puts "  [RPC] Next response constructor: 0x#{constructor.to_s(16)} (#{response_body.bytesize} bytes)"
 
-          if constructor == 0xf35c6d01
-            puts "  [RPC] Next response is rpc_result, extracting payload..."
-            return response_body[12..]
-          end
+          return response_body[12..] if constructor == 0xf35c6d01
 
           if constructor == TL::Message::CONSTRUCTOR_MSG_CONTAINER
-            puts "  [RPC] Next response is also a container, looking for rpc_result..."
             container = TL::MsgContainer.deserialize(response_body)
             rpc_result = container.messages.find { |msg| msg[:body][0, 4].unpack1('L<') == 0xf35c6d01 }
             return rpc_result[:body][12..] if rpc_result
@@ -177,16 +174,11 @@ module MTProto
           return response_body
         end
 
-        puts "  [RPC] No rpc_result found, returning first message body"
         return container.messages.first[:body]
       end
 
-      if constructor == 0xf35c6d01
-        puts "  [RPC] Response is rpc_result, extracting payload..."
-        return response_body[12..]
-      end
+      return response_body[12..] if constructor == 0xf35c6d01
 
-      puts "  [RPC] Returning raw response body (constructor: 0x#{constructor.to_s(16)})"
       response_body
     end
 
@@ -197,7 +189,7 @@ module MTProto
       body
     end
 
-    def init_connection(api_id, device_model, system_version, app_version, system_lang_code, lang_code, query)
+    def init_connection(api_id:, device_model:, system_version:, app_version:, system_lang_code:, lang_pack:, lang_code:, query:)
       body = TL::Serializer.serialize_int(0xc1cd5ea9)
       flags = 0
       body += TL::Serializer.serialize_int(flags)
@@ -206,7 +198,7 @@ module MTProto
       body += TL::Serializer.serialize_string(system_version)
       body += TL::Serializer.serialize_string(app_version)
       body += TL::Serializer.serialize_string(system_lang_code)
-      body += TL::Serializer.serialize_string('')
+      body += TL::Serializer.serialize_string(lang_pack)
       body += TL::Serializer.serialize_string(lang_code)
       body += query
       body
@@ -217,13 +209,41 @@ module MTProto
 
       unless @connection_initialized
         query = init_connection(
-          123456,
-          'Ruby MTProto',
-          'Ruby 3.x',
-          '0.1.0',
-          'en',
-          'en',
-          query
+          api_id: @api_id,
+          device_model: @device_model,
+          system_version: @system_version,
+          app_version: @app_version,
+          system_lang_code: @system_lang_code,
+          lang_pack: @lang_pack,
+          lang_code: @lang_code,
+          query: query
+        )
+        query = invoke_with_layer(214, query)
+        @connection_initialized = true
+      end
+
+      rpc_call(query)
+    end
+
+    def auth_send_code(phone_number, code_settings: {})
+      raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+      query = [0xa677244f].pack('L<')
+      query += TL::Serializer.serialize_string(phone_number)
+      query += TL::Serializer.serialize_int(@api_id)
+      query += TL::Serializer.serialize_string(@api_hash)
+      query += TL::CodeSettings.serialize(code_settings)
+
+      unless @connection_initialized
+        query = init_connection(
+          api_id: @api_id,
+          device_model: @device_model,
+          system_version: @system_version,
+          app_version: @app_version,
+          system_lang_code: @system_lang_code,
+          lang_pack: @lang_pack,
+          lang_code: @lang_code,
+          query: query
         )
         query = invoke_with_layer(214, query)
         @connection_initialized = true

data/lib/mtproto/connection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module MTProto
+  class Connection
+    attr_reader :client
+
+    def initialize(api_id: nil, api_hash: nil, host:, port: 443, public_key:, dc_number:, test_mode: false, timeout: 10)
+      @client = Client.new(
+        api_id: api_id,
+        api_hash: api_hash,
+        host: host,
+        port: port,
+        public_key: public_key,
+        dc_number: dc_number,
+        test_mode: test_mode,
+        timeout: timeout
+      )
+      @connected = false
+    end
+
+    def connect!
+      return if @connected
+
+      @client.connect!
+      @client.make_auth_key
+      @connected = true
+    end
+
+    def disconnect!
+      @client.disconnect! if @connected
+      @connected = false
+    end
+
+    def ping(ping_id = nil)
+      raise NotConnectedError unless @connected
+
+      ping_id ||= rand(2**63)
+      body = TL::Message.ping(ping_id)
+
+      response_body = @client.rpc_call(body)
+      message = TL::Message.new(body: response_body)
+      pong = message.parse_pong
+
+      raise PingMismatchError unless pong[:ping_id] == ping_id
+
+      true
+    end
+
+    def get_config
+      raise NotConnectedError unless @connected
+
+      response = @client.help_get_config
+
+      # Handle gzip compression
+      constructor = response[0, 4].unpack1('L<')
+      if constructor == TL::GzipPacked::CONSTRUCTOR
+        response = TL::GzipPacked.unpack(response)
+        constructor = response[0, 4].unpack1('L<')
+      end
+
+      # Handle RPC errors
+      if constructor == TL::RpcError::CONSTRUCTOR
+        error = TL::RpcError.deserialize(response)
+        raise MTProto::RpcError.new(error.error_code, error.error_message)
+      end
+
+      # Parse and return config
+      if constructor == TL::Config::CONSTRUCTOR || constructor == TL::Config::CONSTRUCTOR_ALT
+        TL::Config.deserialize(response)
+      else
+        raise UnexpectedConstructorError.new(constructor)
+      end
+    end
+
+    def send_code(phone_number, code_settings: {})
+      raise NotConnectedError unless @connected
+      raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
+
+      response = @client.auth_send_code(phone_number, code_settings: code_settings)
+
+      # Handle gzip compression
+      constructor = response[0, 4].unpack1('L<')
+      if constructor == TL::GzipPacked::CONSTRUCTOR
+        response = TL::GzipPacked.unpack(response)
+        constructor = response[0, 4].unpack1('L<')
+      end
+
+      # Handle RPC errors
+      if constructor == TL::RpcError::CONSTRUCTOR
+        error = TL::RpcError.deserialize(response)
+        raise MTProto::RpcError.new(error.error_code, error.error_message)
+      end
+
+      # Parse and return sent code
+      if constructor == TL::SentCode::CONSTRUCTOR
+        sent_code = TL::SentCode.deserialize(response)
+        sent_code.to_h
+      else
+        raise UnexpectedConstructorError.new(constructor)
+      end
+    end
+  end
+end

data/lib/mtproto/crypto/rsa_key.rb

@@ -6,30 +6,24 @@ require 'digest'
 module MTProto
   module Crypto
     class RSAKey
-      TELEGRAM_KEY = <<~PEM
-        -----BEGIN RSA PUBLIC KEY-----
-        MIIBCgKCAQEA6LszBcC1LGzyr992NzE0ieY+BSaOW622Aa9Bd4ZHLl+TuFQ4lo4g
-        5nKaMBwK/BIb9xUfg0Q29/2mgIR6Zr9krM7HjuIcCzFvDtr+L0GQjae9H0pRB2OO
-        62cECs5HKhT5DZ98K33vmWiLowc621dQuwKWSQKjWf50XYFw42h21P2KXUGyp2y/
-        +aEyZ+uVgLLQbRA1dEjSDZ2iGRy12Mk5gpYc397aYp438fsJoHIgJ2lgMv5h7WY9
-        t6N/byY9Nw9p21Og3AoXSL2q/2IJ1WRUhebgAdGVMlV1fkuOQoEzR7EdpqtQD9Cs
-        5+bfo3Nhmcyvk5ftB0WkJ9z6bNZ7yxrP8wIDAQAB
-        -----END RSA PUBLIC KEY-----
-      PEM
-
       attr_reader :key, :fingerprint
 
       def initialize(pem_string)
+        raise ArgumentError, "pem_string is required" if pem_string.nil? || pem_string.empty?
+
         @key = OpenSSL::PKey::RSA.new(pem_string)
         @fingerprint = calculate_fingerprint
       end
 
-      def self.telegram_key
-        @telegram_key ||= new(TELEGRAM_KEY)
+      def self.from_pem(pem_string)
+        new(pem_string)
       end
 
-      def self.find_by_fingerprint(fingerprints)
-        telegram_key if fingerprints.include?(telegram_key.fingerprint)
+      def self.find_by_fingerprint(fingerprints, public_key)
+        raise ArgumentError, "public_key is required" if public_key.nil? || public_key.empty?
+
+        key = new(public_key)
+        key if fingerprints.include?(key.fingerprint)
       end
 
       private

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/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

data/lib/mtproto/tl/message.rb

@@ -74,6 +74,12 @@ module MTProto
       end
 
       def self.deserialize(data)
+        if data.bytesize < 20
+          raise(ArgumentError,
+            "Invalid MTProto message: expected at least 20 bytes, got #{data.bytesize} bytes (hex: #{data.unpack1('H*')})",
+          )
+        end
+
         auth_key_id = data[0, 8].unpack1('Q<')
         msg_id = data[8, 8].unpack1('Q<')
         body_length = data[16, 4].unpack1('L<')

data/lib/mtproto/tl/sent_code.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class SentCode
+      CONSTRUCTOR = 0x5e002502
+
+      attr_reader :flags, :type, :phone_code_hash, :next_type, :timeout
+
+      def self.deserialize(data)
+        offset = 4
+
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        type, type_bytes_read = SentCodeType.deserialize_from(data[offset..])
+        offset += type_bytes_read
+
+        phone_code_hash_length = data[offset].ord
+        offset += 1
+
+        phone_code_hash = data[offset, phone_code_hash_length]
+        offset += phone_code_hash_length
+
+        padding = (4 - ((phone_code_hash_length + 1) % 4)) % 4
+        offset += padding
+
+        next_type = nil
+        if (flags & (1 << 1)) != 0
+          next_type, next_type_bytes_read = CodeType.deserialize_from(data[offset..])
+          offset += next_type_bytes_read
+        end
+
+        timeout = nil
+        if (flags & (1 << 2)) != 0
+          timeout = data[offset, 4].unpack1('L<')
+        end
+
+        new(
+          flags: flags,
+          type: type,
+          phone_code_hash: phone_code_hash,
+          next_type: next_type,
+          timeout: timeout
+        )
+      end
+
+      def initialize(flags:, type:, phone_code_hash:, next_type: nil, timeout: nil)
+        @flags = flags
+        @type = type
+        @phone_code_hash = phone_code_hash
+        @next_type = next_type
+        @timeout = timeout
+      end
+
+      def to_h
+        {
+          phone_code_hash: @phone_code_hash,
+          type: @type,
+          next_type: @next_type,
+          timeout: @timeout
+        }.compact
+      end
+    end
+
+    module SentCodeType
+      def self.deserialize_from(data)
+        constructor = data[0, 4].unpack1('L<')
+        offset = 4
+
+        case constructor
+        when 0x3dbb5986 # auth.sentCodeTypeApp
+          length = data[offset, 4].unpack1('L<')
+          offset += 4
+          [{ _: :sent_code_type_app, length: length }, offset]
+        when 0xc000bba2 # auth.sentCodeTypeSms
+          length = data[offset, 4].unpack1('L<')
+          offset += 4
+          [{ _: :sent_code_type_sms, length: length }, offset]
+        when 0x5353e5a7 # auth.sentCodeTypeCall
+          length = data[offset, 4].unpack1('L<')
+          offset += 4
+          [{ _: :sent_code_type_call, length: length }, offset]
+        when 0xab03c6d9 # auth.sentCodeTypeFlashCall
+          pattern_length = data[offset].ord
+          offset += 1
+          pattern = data[offset, pattern_length]
+          offset += pattern_length
+          padding = (4 - ((pattern_length + 1) % 4)) % 4
+          offset += padding
+          [{ _: :sent_code_type_flash_call, pattern: pattern }, offset]
+        when 0x82006484 # auth.sentCodeTypeMissedCall
+          prefix_length = data[offset].ord
+          offset += 1
+          prefix = data[offset, prefix_length]
+          offset += prefix_length
+          padding = (4 - ((prefix_length + 1) % 4)) % 4
+          offset += padding
+          length = data[offset, 4].unpack1('L<')
+          offset += 4
+          [{ _: :sent_code_type_missed_call, prefix: prefix, length: length }, offset]
+        else
+          raise "Unknown SentCodeType constructor: 0x#{constructor.to_s(16)}"
+        end
+      end
+    end
+
+    module CodeType
+      def self.deserialize_from(data)
+        constructor = data[0, 4].unpack1('L<')
+        offset = 4
+
+        case constructor
+        when 0x72a3158c # codeTypeSms
+          [{ _: :code_type_sms }, offset]
+        when 0x741cd3e3 # codeTypeCall
+          [{ _: :code_type_call }, offset]
+        when 0x226ccefb # codeTypeFlashCall
+          [{ _: :code_type_flash_call }, offset]
+        when 0xd61ad6ee # codeTypeMissedCall
+          [{ _: :code_type_missed_call }, offset]
+        else
+          raise "Unknown CodeType constructor: 0x#{constructor.to_s(16)}"
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/transport/tcp_connection.rb

@@ -17,7 +17,7 @@ module MTProto
         @socket = nil
       end
 
-      def connect
+      def connect!
         return if connected?
 
         @socket = TCPSocket.new(@host, @port)

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/mtproto.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'mtproto/version'
+require_relative 'mtproto/errors'
 require_relative 'mtproto/transport/abridged_packet_codec'
 require_relative 'mtproto/transport/tcp_connection'
 require_relative 'mtproto/tl/message'
@@ -14,6 +15,8 @@ require_relative 'mtproto/tl/new_session_created'
 require_relative 'mtproto/tl/rpc_error'
 require_relative 'mtproto/tl/gzip_packed'
 require_relative 'mtproto/tl/config'
+require_relative 'mtproto/tl/code_settings'
+require_relative 'mtproto/tl/sent_code'
 require_relative 'mtproto/crypto/rsa_key'
 require_relative 'mtproto/crypto/factorization'
 require_relative 'mtproto/crypto/aes_ige'
@@ -26,6 +29,7 @@ require_relative 'mtproto/auth_key_generator'
 require_relative 'mtproto/session'
 require_relative 'mtproto/encrypted_message'
 require_relative 'mtproto/client'
+require_relative 'mtproto/connection'
 
 module MTProto
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Artem Levenkov
@@ -17,19 +17,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".ruby-version"
 - Rakefile
 - ext/aes_ige/Makefile
-- ext/aes_ige/aes_ige.bundle
 - ext/aes_ige/aes_ige.c
 - ext/aes_ige/extconf.rb
 - ext/factorization/Makefile
 - ext/factorization/extconf.rb
-- ext/factorization/factorization.bundle
 - ext/factorization/factorization.c
 - lib/mtproto.rb
 - lib/mtproto/auth_key_generator.rb
 - lib/mtproto/client.rb
+- lib/mtproto/connection.rb
 - lib/mtproto/crypto/aes_ige.rb
 - lib/mtproto/crypto/auth_key_helper.rb
 - lib/mtproto/crypto/dh_key_exchange.rb
@@ -39,9 +39,11 @@ files:
 - lib/mtproto/crypto/rsa_key.rb
 - lib/mtproto/crypto/rsa_pad.rb
 - lib/mtproto/encrypted_message.rb
+- lib/mtproto/errors.rb
 - lib/mtproto/session.rb
 - lib/mtproto/tl/bad_msg_notification.rb
 - lib/mtproto/tl/client_dh_inner_data.rb
+- lib/mtproto/tl/code_settings.rb
 - lib/mtproto/tl/config.rb
 - lib/mtproto/tl/gzip_packed.rb
 - lib/mtproto/tl/message.rb
@@ -49,6 +51,7 @@ files:
 - lib/mtproto/tl/new_session_created.rb
 - lib/mtproto/tl/p_q_inner_data.rb
 - lib/mtproto/tl/rpc_error.rb
+- lib/mtproto/tl/sent_code.rb
 - lib/mtproto/tl/serializer.rb
 - lib/mtproto/tl/server_dh_inner_data.rb
 - lib/mtproto/transport/abridged_packet_codec.rb