mtproto 0.0.8 → 0.0.10

data/lib/mtproto/type/rpc/updates/get_state.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module RPC
-      module Updates
-        class GetState
-          CONSTRUCTOR = 0xedd4882a
-
-          def self.build
-            [CONSTRUCTOR].pack('L<')
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/updates/state.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../gzip_packed'
-require_relative '../../rpc_error'
-
-module MTProto
-  module Type
-    module RPC
-      module Updates
-        class State
-          CONSTRUCTOR = 0xa56c2a3e
-
-          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
-
-            raise "Expected State constructor 0x#{CONSTRUCTOR.to_s(16)}, got 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
-
-            # updates.state#a56c2a3e pts:int qts:int date:int seq:int unread_count:int = updates.State;
-            pts = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            qts = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            date = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            seq = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            unread_count = response[offset, 4].unpack1('L<')
-
-            {
-              pts: pts,
-              qts: qts,
-              date: date,
-              seq: seq,
-              unread_count: unread_count
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/rpc/users/get_users.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module RPC
-      module Users
-        class GetUsers
-          CONSTRUCTOR = 0x0d91a548
-          INPUT_USER_SELF = 0xf7c1b13f
-
-          def self.build
-            query = [CONSTRUCTOR].pack('L<')
-
-            # Vector of InputUser with one element: inputUserSelf
-            query += [0x1cb5c415].pack('L<') # vector constructor
-            query += [1].pack('L<') # count = 1
-            query += [INPUT_USER_SELF].pack('L<') # inputUserSelf
-
-            query
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../gzip_packed'
-require_relative '../../rpc_error'
-
-module MTProto
-  module Type
-    module RPC
-      module Users
-        class Users
-          VECTOR_CONSTRUCTOR = 0x1cb5c415
-          USER_CONSTRUCTOR = 0x020b1422
-
-          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
-
-            # Expect Vector<User>
-            raise "Expected Vector constructor, got 0x#{constructor.to_s(16)}" unless constructor == VECTOR_CONSTRUCTOR
-
-            count = response[offset, 4].unpack1('L<')
-            offset += 4
-
-            users = []
-            count.times do
-              user_constructor = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              next unless user_constructor == USER_CONSTRUCTOR
-
-              # Parse User: flags:# flags2:# id:long access_hash:flags.0?long first_name:flags.1?string ...
-              flags = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              flags2 = response[offset, 4].unpack1('L<')
-              offset += 4
-
-              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
-
-              first_name = nil
-              if (flags & (1 << 1)) != 0
-                len = response[offset].unpack1('C')
-                offset += 1
-                first_name = response[offset, len]
-                offset += len
-                padding = (4 - ((1 + len) % 4)) % 4
-                offset += padding
-              end
-
-              last_name = nil
-              if (flags & (1 << 2)) != 0
-                len = response[offset].unpack1('C')
-                offset += 1
-                last_name = response[offset, len]
-                offset += len
-                padding = (4 - ((1 + len) % 4)) % 4
-                offset += padding
-              end
-
-              users << {
-                id: id,
-                access_hash: access_hash,
-                first_name: first_name,
-                last_name: last_name,
-                flags: flags,
-                flags2: flags2
-              }
-
-              # Skip remaining fields - we don't need them for this test
-              break
-            end
-
-            users
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mtproto/type/sent_code.rb

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    module Serializer
-      module_function
-
-      def serialize_int(value)
-        [value].pack('L<')
-      end
-
-      def serialize_long(value)
-        [value].pack('Q<')
-      end
-
-      def serialize_int128(value)
-        value.is_a?(String) ? value : [value].pack('Q<Q<')
-      end
-
-      def serialize_int256(value)
-        value.is_a?(String) ? value : [value].pack('Q<Q<Q<Q<')
-      end
-
-      def serialize_bytes(bytes)
-        length = bytes.bytesize
-
-        if length <= 253
-          [length].pack('C').b + bytes.b + padding(length + 1)
-        else
-          [254].pack('C').b + [length].pack('L<')[0, 3].b + bytes.b + padding(length + 4)
-        end
-      end
-
-      def serialize_string(str)
-        serialize_bytes(str)
-      end
-
-      def padding(current_length)
-        pad_length = (4 - (current_length % 4)) % 4
-        ("\x00" * pad_length).b
-      end
-
-      def integer_to_bytes(int)
-        return "\x00" if int.zero?
-
-        bytes = []
-        while int > 0
-          bytes.unshift(int & 0xff)
-          int >>= 8
-        end
-        bytes.pack('C*')
-      end
-    end
-  end
-end

data/lib/mtproto/type/server_dh_inner_data.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module MTProto
-  module Type
-    class ServerDHInnerData
-      CONSTRUCTOR = 0xb5890dba
-
-      attr_reader :nonce, :server_nonce, :g, :dh_prime, :g_a, :server_time
-
-      def self.deserialize(data)
-        constructor = data[0, 4].unpack1('L<')
-        raise "Unexpected constructor: 0x#{constructor.to_s(16)}" unless constructor == CONSTRUCTOR
-
-        offset = 4
-
-        nonce = data[offset, 16]
-        offset += 16
-
-        server_nonce = data[offset, 16]
-        offset += 16
-
-        g = data[offset, 4].unpack1('L<')
-        offset += 4
-
-        dh_prime_length_byte = data[offset].ord
-        offset += 1
-
-        if dh_prime_length_byte == 254
-          length_bytes = data[offset, 3].bytes
-          dh_prime_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
-          offset += 3
-        else
-          dh_prime_length = dh_prime_length_byte
-        end
-
-        dh_prime = data[offset, dh_prime_length]
-        offset += dh_prime_length
-        offset += padding_length(dh_prime_length_byte == 254 ? dh_prime_length + 4 : dh_prime_length + 1)
-
-        g_a_length_byte = data[offset].ord
-        offset += 1
-
-        if g_a_length_byte == 254
-          length_bytes = data[offset, 3].bytes
-          g_a_length = length_bytes[0] | (length_bytes[1] << 8) | (length_bytes[2] << 16)
-          offset += 3
-        else
-          g_a_length = g_a_length_byte
-        end
-
-        g_a = data[offset, g_a_length]
-        offset += g_a_length
-        offset += padding_length(g_a_length_byte == 254 ? g_a_length + 4 : g_a_length + 1)
-
-        server_time = data[offset, 4].unpack1('L<')
-
-        new(
-          nonce: nonce,
-          server_nonce: server_nonce,
-          g: g,
-          dh_prime: dh_prime,
-          g_a: g_a,
-          server_time: server_time
-        )
-      end
-
-      def initialize(nonce:, server_nonce:, g:, dh_prime:, g_a:, server_time:)
-        @nonce = nonce
-        @server_nonce = server_nonce
-        @g = g
-        @dh_prime = dh_prime
-        @g_a = g_a
-        @server_time = server_time
-      end
-
-      def self.padding_length(length)
-        (4 - (length % 4)) % 4
-      end
-
-      def padding_length(length)
-        self.class.padding_length(length)
-      end
-    end
-  end
-end