mtproto 0.0.8 → 0.0.10

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    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/type/auth_key/set_client_dh_params.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../serializer'
-
-module MTProto
-  module Type
-    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/type/bad_msg_notification.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    class BadMsgNotification
-      CONSTRUCTOR = 0xa7eff811
-
-      attr_reader :bad_msg_id, :bad_msg_seqno, :error_code
-
-      def self.deserialize(data)
-        offset = 4
-        bad_msg_id = data[offset, 8].unpack1('Q<')
-        offset += 8
-
-        bad_msg_seqno = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        error_code = data[offset, 4].unpack1('L<')
-
-        new(bad_msg_id: bad_msg_id, bad_msg_seqno: bad_msg_seqno, error_code: error_code)
-      end
-
-      def initialize(bad_msg_id:, bad_msg_seqno:, error_code:)
-        @bad_msg_id = bad_msg_id
-        @bad_msg_seqno = bad_msg_seqno
-        @error_code = error_code
-      end
-
-      def error_message
-        case @error_code
-        when 16 then "msg_id too low (client time is wrong)"
-        when 17 then "msg_id too high (client time needs sync)"
-        when 18 then "incorrect two lower order msg_id bits (must be divisible by 4)"
-        when 19 then "container msg_id is the same as previously received"
-        when 20 then "message too old"
-        when 32 then "msg_seqno too low"
-        when 33 then "msg_seqno too high"
-        when 34 then "even msg_seqno expected but odd received"
-        when 35 then "odd msg_seqno expected but even received"
-        when 48 then "incorrect server salt"
-        else "unknown error code #{@error_code}"
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/client_dh_inner_data.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'serializer'
-
-module MTProto
-  module Type
-    class ClientDHInnerData
-      CONSTRUCTOR = 0x6643b654
-
-      attr_reader :nonce, :server_nonce, :retry_id, :g_b
-
-      def initialize(nonce:, server_nonce:, retry_id:, g_b:)
-        @nonce = nonce
-        @server_nonce = server_nonce
-        @retry_id = retry_id
-        @g_b = g_b
-      end
-
-      def serialize
-        data = Serializer.serialize_int(CONSTRUCTOR)
-        data += @nonce
-        data += @server_nonce
-        data += Serializer.serialize_long(@retry_id)
-        data += Serializer.serialize_bytes(@g_b)
-        data
-      end
-    end
-  end
-end

data/lib/mtproto/type/code_settings.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    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/type/config.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    class Config
-      CONSTRUCTOR = 0xcc1a241e
-      CONSTRUCTOR_ALT = 0x3072cfa1
-
-      attr_reader :flags, :date, :expires, :test_mode, :this_dc, :dc_options
-
-      def self.deserialize(data)
-        offset = 4
-
-        flags = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        date = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        expires = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        test_mode = (data[offset, 4].unpack1('L<') == 0x997275b5)
-        offset += 4
-
-        this_dc = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        dc_options_constructor = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        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
-
-        dc_options = []
-        dc_options_count.times do
-          dc_option, bytes_read = DcOption.deserialize_from(data[offset..])
-          dc_options << dc_option
-          offset += bytes_read
-        end
-
-        new(
-          flags: flags,
-          date: date,
-          expires: expires,
-          test_mode: test_mode,
-          this_dc: this_dc,
-          dc_options: dc_options
-        )
-      end
-
-      def initialize(flags:, date:, expires:, test_mode:, this_dc:, dc_options:)
-        @flags = flags
-        @date = date
-        @expires = expires
-        @test_mode = test_mode
-        @this_dc = this_dc
-        @dc_options = dc_options
-      end
-    end
-
-    class DcOption
-      attr_reader :id, :ip_address, :port, :flags
-
-      def self.deserialize_from(data)
-        offset = 0
-
-        constructor = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        raise "Expected dcOption constructor 0x18b7a10d, got 0x#{constructor.to_s(16)}" unless constructor == 0x18b7a10d
-
-        flags = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        id = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        ip_length = data[offset].ord
-        offset += 1
-
-        ip_address = data[offset, ip_length]
-        offset += ip_length
-
-        padding = (4 - ((ip_length + 1) % 4)) % 4
-        offset += padding
-
-        port = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        [new(id: id, ip_address: ip_address, port: port, flags: flags), offset]
-      end
-
-      def initialize(id:, ip_address:, port:, flags:)
-        @id = id
-        @ip_address = ip_address
-        @port = port
-        @flags = flags
-      end
-
-      def ipv6?
-        (@flags & 1) != 0
-      end
-
-      def media_only?
-        (@flags & 2) != 0
-      end
-
-      def tcpo_only?
-        (@flags & 4) != 0
-      end
-
-      def cdn?
-        (@flags & 8) != 0
-      end
-
-      def static?
-        (@flags & 16) != 0
-      end
-    end
-  end
-end

data/lib/mtproto/type/pq_inner_data.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'serializer'
-
-module MTProto
-  module Type
-    class PQInnerData
-      CONSTRUCTOR_DC = 0xa9f55f95
-      CONSTRUCTOR_TEMP_DC = 0x56fddf88
-
-      attr_reader :pq, :p, :q, :nonce, :server_nonce, :new_nonce, :dc, :expires_in
-
-      def initialize(pq:, p:, q:, nonce:, server_nonce:, new_nonce:, dc:, expires_in: nil)
-        @pq = pq
-        @p = p
-        @q = q
-        @nonce = nonce
-        @server_nonce = server_nonce
-        @new_nonce = new_nonce
-        @dc = dc
-        @expires_in = expires_in
-      end
-
-      def serialize
-        constructor = @expires_in ? CONSTRUCTOR_TEMP_DC : CONSTRUCTOR_DC
-
-        data = Serializer.serialize_int(constructor)
-        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@pq))
-        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@p))
-        data += Serializer.serialize_bytes(Serializer.integer_to_bytes(@q))
-        data += @nonce
-        data += @server_nonce
-        data += @new_nonce
-
-        data += Serializer.serialize_int(@expires_in) if @expires_in
-
-        data + Serializer.serialize_int(@dc)
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/auth/authorization.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../gzip_packed'
-require_relative '../../rpc_error'
-
-module MTProto
-  module Type
-    module RPC
-      module Auth
-        class Authorization
-          CONSTRUCTOR = 0x2ea2c0d4
-          CONSTRUCTOR_SIGN_UP_REQUIRED = 0x44747e9a
-
-          def self.parse(response)
-            constructor = response[0, 4].unpack1('L<')
-
-            if constructor == Type::GzipPacked::CONSTRUCTOR
-              response = Type::GzipPacked.unpack(response)
-              constructor = response[0, 4].unpack1('L<')
-            end
-
-            if constructor == Type::RpcError::CONSTRUCTOR
-              error = Type::RpcError.deserialize(response)
-              raise MTProto::RpcError.new(error.error_code, error.error_message)
-            end
-
-            if constructor == CONSTRUCTOR_SIGN_UP_REQUIRED
-              return { authorization: nil, sign_up_required: true }
-            end
-
-            if constructor == CONSTRUCTOR
-              offset = 4
-
-              # Parse flags
-              flags = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              # tmp_sessions:flags.0?int
-              if (flags & (1 << 0)) != 0
-                offset += 4
-              end
-
-              # otherwise_relogin_days:flags.1?int
-              if (flags & (1 << 1)) != 0
-                offset += 4
-              end
-
-              # future_auth_token:flags.2?bytes
-              if (flags & (1 << 2)) != 0
-                first_byte = response[offset].unpack1('C')
-
-                if first_byte < 254
-                  # Short format: 1 byte length + data + padding
-                  token_len = first_byte
-                  offset += 1 + token_len
-                  padding = (4 - ((1 + token_len) % 4)) % 4
-                  offset += padding
-                else
-                  # Long format: 0xfe + 3 bytes length + data + padding
-                  offset += 1
-                  token_len = response[offset, 3].unpack('CCC').inject(0) {|sum, b| (sum << 8) + b}
-                  offset += 3 + token_len
-                  padding = (4 - ((4 + token_len) % 4)) % 4
-                  offset += padding
-                end
-              end
-
-              # Parse User object
-              # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
-              user_constructor = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              user_flags = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              user_flags2 = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              # id:long (always present)
-              user_id = response[offset, 8].unpack1('Q<')
-              offset += 8
-
-              # access_hash:flags.0?long (conditional on flags.0)
-              access_hash = nil
-              if (user_flags & (1 << 0)) != 0
-                access_hash = response[offset, 8].unpack1('Q<')
-                offset += 8
-              end
-
-              # We have what we need, skip the rest of User fields
-
-              return {
-                authorization: true,
-                flags: flags,
-                sign_up_required: false,
-                user_id: user_id,
-                access_hash: access_hash
-              }
-            end
-
-            raise UnexpectedConstructorError.new(constructor)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/auth/send_code.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../serializer'
-require_relative '../../code_settings'
-
-module MTProto
-  module Type
-    module RPC
-      module Auth
-        class SendCode
-          CONSTRUCTOR = 0xa677244f
-
-          def self.build(phone_number:, api_id:, api_hash:, code_settings: {})
-            raise ArgumentError, 'phone_number is required' if phone_number.nil? || phone_number.empty?
-
-            query = [CONSTRUCTOR].pack('L<')
-            query += Serializer.serialize_string(phone_number)
-            query += Serializer.serialize_int(api_id)
-            query += Serializer.serialize_string(api_hash)
-            query += CodeSettings.serialize(code_settings)
-
-            query
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/auth/sent_code.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../gzip_packed'
-require_relative '../../rpc_error'
-require_relative '../../sent_code'
-
-module MTProto
-  module Type
-    module RPC
-      module Auth
-        class SentCode
-          def self.parse(response)
-            constructor = response[0, 4].unpack1('L<')
-
-            if constructor == Type::GzipPacked::CONSTRUCTOR
-              response = Type::GzipPacked.unpack(response)
-              constructor = response[0, 4].unpack1('L<')
-            end
-
-            if constructor == Type::RpcError::CONSTRUCTOR
-              error = Type::RpcError.deserialize(response)
-              raise MTProto::RpcError.new(error.error_code, error.error_message)
-            end
-
-            if constructor == Type::SentCode::CONSTRUCTOR
-              sent_code = Type::SentCode.deserialize(response)
-              sent_code.to_h
-            else
-              raise UnexpectedConstructorError.new(constructor)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/auth/sign_in.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../serializer'
-
-module MTProto
-  module Type
-    module RPC
-      module Auth
-        class SignIn
-          CONSTRUCTOR = 0x8d52a951
-
-          def self.build(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?
-
-            flags = 0
-            flags |= (1 << 0) # phone_code present
-
-            query = [CONSTRUCTOR].pack('L<')
-            query += Serializer.serialize_int(flags)
-            query += Serializer.serialize_string(phone_number)
-            query += Serializer.serialize_string(phone_code_hash)
-            query += Serializer.serialize_string(phone_code)
-
-            query
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/contacts/contacts.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../gzip_packed'
-require_relative '../../rpc_error'
-
-module MTProto
-  module Type
-    module RPC
-      module Contacts
-        class Contacts
-          CONSTRUCTOR_CONTACTS = 0xeae87e42
-          CONSTRUCTOR_CONTACTS_NOT_MODIFIED = 0xb74ba9d2
-          VECTOR_CONSTRUCTOR = 0x1cb5c415
-
-          def self.parse(response)
-            offset = 0
-
-            constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            if constructor == Type::GzipPacked::CONSTRUCTOR
-              response = Type::GzipPacked.unpack(response)
-              constructor = response[0, 4].unpack1('L<')
-              offset = 4
-            end
-
-            if constructor == Type::RpcError::CONSTRUCTOR
-              error = Type::RpcError.deserialize(response)
-              raise MTProto::RpcError.new(error.error_code, error.error_message)
-            end
-
-            case constructor
-            when CONSTRUCTOR_CONTACTS_NOT_MODIFIED
-              # contacts.contactsNotModified#b74ba9d2 = contacts.Contacts;
-              {
-                contacts: [],
-                users: []
-              }
-
-            when CONSTRUCTOR_CONTACTS
-              # contacts.contacts#eae87e42 contacts:Vector<Contact> saved_count:int users:Vector<User> = contacts.Contacts;
-
-              # Parse contacts vector
-              contacts, offset = parse_contacts_vector(response, offset)
-
-              # Parse saved_count
-              saved_count = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              # Parse users vector
-              users, offset = parse_users_vector(response, offset)
-
-              {
-                contacts: contacts,
-                saved_count: saved_count,
-                users: users
-              }
-
-            else
-              raise "Unknown Contacts constructor: 0x#{constructor.to_s(16)}"
-            end
-          end
-
-          def self.parse_contacts_vector(response, offset)
-            vector_constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            return [[], offset] unless vector_constructor == VECTOR_CONSTRUCTOR
-
-            count = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            contacts = []
-            count.times do
-              contact, offset = parse_contact(response, offset)
-              contacts << contact if contact
-            end
-
-            [contacts, offset]
-          end
-
-          def self.parse_contact(response, offset)
-            # contact#145ade0b user_id:long mutual:Bool
-            constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            return [nil, offset] unless constructor == 0x145ade0b
-
-            user_id = response[offset, 8].unpack1('Q<')
-            offset += 8
-
-            mutual_constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-            mutual = mutual_constructor == 0x997275b5 # boolTrue
-
-            [{
-              user_id: user_id,
-              mutual: mutual
-            }, offset]
-          rescue StandardError
-            [nil, offset]
-          end
-
-          def self.parse_users_vector(response, offset)
-            vector_constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            return [[], offset] unless vector_constructor == VECTOR_CONSTRUCTOR
-
-            count = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            users = []
-            count.times do
-              user, offset = parse_user(response, offset)
-              users << user if user
-            end
-
-            [users, offset]
-          end
-
-          def self.parse_user(response, offset)
-            user_constructor = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
-            return [nil, offset] unless user_constructor == 0x20b1422
-
-            flags = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            flags2 = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            user_id = response[offset, 8].unpack1('Q<')
-            offset += 8
-
-            access_hash = nil
-            if (flags & (1 << 0)) != 0
-              access_hash = response[offset, 8].unpack1('Q<')
-              offset += 8
-            end
-
-            [{
-              id: user_id,
-              access_hash: access_hash
-            }, offset]
-          rescue StandardError
-            [nil, offset]
-          end
-        end
-      end
-    end
-  end
-end