mtproto 0.0.8 → 0.0.9

data/lib/mtproto/tl/object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Object
+      extend Binary
+
+      attr_reader :constructor, :payload
+
+      def initialize(constructor, payload)
+        @constructor = constructor
+        @payload = payload
+      end
+
+      def self.parse(message)
+        body = message.body
+        constructor_id = b_u32(body[0, 4])
+        constructor = Constructors::NAMES.fetch(constructor_id)
+        payload = body[4..]
+
+        new(constructor, payload)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/account_password.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class AccountPassword
+      CONSTRUCTOR = 0x957b50fb
+      ALGO_SHA256_MOD_POW = 0x3a912d4a
+
+      attr_reader :has_password, :current_algo, :srp_b, :srp_id
+
+      def initialize(has_password:, current_algo: nil, srp_b: nil, srp_id: nil)
+        @has_password = has_password
+        @current_algo = current_algo
+        @srp_b = srp_b
+        @srp_id = srp_id
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+
+        offset = 4
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        has_password = flags.anybits?(1 << 2)
+
+        return new(has_password: false) unless has_password
+
+        algo_constructor = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        current_algo = nil
+        if algo_constructor == ALGO_SHA256_MOD_POW
+          salt1, offset = read_tl_bytes(data, offset)
+          salt2, offset = read_tl_bytes(data, offset)
+          g = data[offset, 4].unpack1('l<')
+          offset += 4
+          p, offset = read_tl_bytes(data, offset)
+
+          current_algo = { salt1: salt1, salt2: salt2, g: g, p: p }
+        end
+
+        srp_b, offset = read_tl_bytes(data, offset)
+        srp_id = data[offset, 8].unpack1('Q<')
+
+        new(has_password: true, current_algo: current_algo, srp_b: srp_b, srp_id: srp_id)
+      end
+
+      class << self
+        private
+
+        def read_tl_bytes(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte < 254
+            len = first_byte
+            bytes = data[offset + 1, len]
+            total = 1 + len
+          else
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            bytes = data[offset + 4, len]
+            total = 4 + len
+          end
+          padding = (4 - (total % 4)) % 4
+          [bytes, offset + total + padding]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/authorization.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class Authorization
+      CONSTRUCTOR = 0x2ea2c0d4
+      CONSTRUCTOR_SIGN_UP_REQUIRED = 0x44747e9a
+
+      attr_reader :user_id, :access_hash, :flags, :sign_up_required
+
+      def initialize(user_id: nil, access_hash: nil, flags: 0, sign_up_required: false)
+        @user_id = user_id
+        @access_hash = access_hash
+        @flags = flags
+        @sign_up_required = sign_up_required
+      end
+
+      def authorization?
+        !@sign_up_required && @user_id
+      end
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+
+        return new(sign_up_required: true) if constructor == CONSTRUCTOR_SIGN_UP_REQUIRED
+        raise UnexpectedConstructorError, constructor unless constructor == CONSTRUCTOR
+
+        offset = 4
+
+        flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        offset += 4 if flags.anybits?(1 << 0) # tmp_sessions
+        offset += 4 if flags.anybits?(1 << 1) # otherwise_relogin_days
+
+        offset = skip_tl_bytes(data, offset) if flags.anybits?(1 << 2) # future_auth_token
+
+        # user#20b1422 flags:# flags2:# id:long access_hash:flags.0?long ...
+        offset += 4 # user constructor
+
+        user_flags = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        offset += 4 # flags2
+
+        user_id = data[offset, 8].unpack1('Q<')
+        offset += 8
+
+        access_hash = nil
+        access_hash = data[offset, 8].unpack1('Q<') if user_flags.anybits?(1 << 0)
+
+        new(user_id: user_id, access_hash: access_hash, flags: flags)
+      end
+
+      class << self
+        private
+
+        def skip_tl_bytes(data, offset)
+          first_byte = data.getbyte(offset)
+          if first_byte < 254
+            total = 1 + first_byte
+          else
+            len = data.getbyte(offset + 1) |
+                  (data.getbyte(offset + 2) << 8) |
+                  (data.getbyte(offset + 3) << 16)
+            total = 4 + len
+          end
+          offset + total + ((4 - (total % 4)) % 4)
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/check_password.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class CheckPassword
+      include Binary
+
+      CONSTRUCTOR = 0xd18b4d16
+      INPUT_CHECK_PASSWORD_SRP = 0xd27ff082
+
+      attr_reader :srp_id, :a, :m1
+
+      def initialize(srp_id:, a:, m1:)
+        @srp_id = srp_id
+        @a = a
+        @m1 = m1
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) +
+          u32_b(INPUT_CHECK_PASSWORD_SRP) +
+          u64_b(@srp_id) +
+          serialize_tl_bytes(@a) +
+          serialize_tl_bytes(@m1)
+      end
+
+      private
+
+      def serialize_tl_bytes(data)
+        bytes = data.bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/client_dh_inner_data.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ClientDHInnerData
+      include Binary
+
+      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 body
+        result = u32_b(CONSTRUCTOR)
+        result += @nonce.bytes
+        result += @server_nonce.bytes
+        result += u64_b(@retry_id)
+        result += serialize_tl_bytes(@g_b.bytes)
+
+        result
+      end
+
+      private
+
+      def serialize_tl_bytes(bytes)
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/dh_gen_response.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class DHGenResponse
+      extend Binary
+
+      CONSTRUCTOR_OK = 0x3bcbf734
+      CONSTRUCTOR_RETRY = 0x46dc1fb9
+      CONSTRUCTOR_FAIL = 0xa69dae02
+
+      attr_reader :status, :nonce, :server_nonce, :new_nonce_hash
+
+      def self.parse(message)
+        data = message.body
+        constructor = b_u32(data[0, 4])
+
+        status = case constructor
+                 when CONSTRUCTOR_OK then :ok
+                 when CONSTRUCTOR_RETRY then :retry
+                 when CONSTRUCTOR_FAIL then :fail
+                 else raise "Unexpected constructor: 0x#{constructor.to_s(16)}"
+                 end
+
+        offset = 4
+        nonce = data[offset, 16].pack('C*')
+        offset += 16
+        server_nonce = data[offset, 16].pack('C*')
+        offset += 16
+        new_nonce_hash = data[offset, 16].pack('C*')
+
+        new(
+          status: status,
+          nonce: nonce,
+          server_nonce: server_nonce,
+          new_nonce_hash: new_nonce_hash
+        )
+      end
+
+      private
+
+      def initialize(status:, nonce:, server_nonce:, new_nonce_hash:)
+        @status = status
+        @nonce = nonce
+        @server_nonce = server_nonce
+        @new_nonce_hash = new_nonce_hash
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/export_login_token.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ExportLoginToken
+      include Binary
+
+      CONSTRUCTOR = 0xb7e085fe
+      VECTOR_CONSTRUCTOR = 0x1cb5c415
+
+      attr_reader :api_id, :api_hash, :except_ids
+
+      def initialize(api_id:, api_hash:, except_ids: [])
+        @api_id = api_id
+        @api_hash = api_hash
+        @except_ids = except_ids
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) +
+          u32_b(@api_id) +
+          serialize_tl_string(@api_hash) +
+          serialize_vector_long(@except_ids)
+      end
+
+      private
+
+      def serialize_vector_long(ids)
+        result = u32_b(VECTOR_CONSTRUCTOR) + u32_b(ids.length)
+        ids.each { |id| result += u64_b(id) }
+        result
+      end
+
+      def serialize_tl_string(str)
+        bytes = str.encode('UTF-8').bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/get_config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetConfig
+      include Binary
+
+      CONSTRUCTOR = 0xc4f9186b
+
+      def body
+        u32_b(CONSTRUCTOR)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/get_difference.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetDifference
+      include Binary
+
+      CONSTRUCTOR = 0x19c2f763
+
+      attr_reader :pts, :date, :qts, :pts_limit, :pts_total_limit, :qts_limit
+
+      def initialize(pts:, date:, qts:, pts_limit: nil, pts_total_limit: nil, qts_limit: nil)
+        @pts = pts
+        @date = date
+        @qts = qts
+        @pts_limit = pts_limit
+        @pts_total_limit = pts_total_limit
+        @qts_limit = qts_limit
+      end
+
+      def body
+        flags = 0
+        flags |= (1 << 0) if @pts_limit
+        flags |= (1 << 1) if @pts_total_limit
+        flags |= (1 << 2) if @qts_limit
+
+        result = u32_b(CONSTRUCTOR) + u32_b(flags) + u32_b(@pts)
+        result += u32_b(@pts_limit) if @pts_limit
+        result += u32_b(@pts_total_limit) if @pts_total_limit
+        result += u32_b(@date) + u32_b(@qts)
+        result += u32_b(@qts_limit) if @qts_limit
+        result
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/get_password.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetPassword
+      include Binary
+
+      CONSTRUCTOR = 0x548a30f5
+
+      def body
+        u32_b(CONSTRUCTOR)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/get_state.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetState
+      include Binary
+
+      CONSTRUCTOR = 0xedd4882a
+
+      def body
+        u32_b(CONSTRUCTOR)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/get_users.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class GetUsers
+      include Binary
+
+      CONSTRUCTOR = 0x0d91a548
+      VECTOR_CONSTRUCTOR = 0x1cb5c415
+      INPUT_USER_SELF = 0xf7c1b13f
+
+      def body
+        u32_b(CONSTRUCTOR) +
+          u32_b(VECTOR_CONSTRUCTOR) +
+          u32_b(1) +
+          u32_b(INPUT_USER_SELF)
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/help_config.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class HelpConfig
+      CONSTRUCTOR = 0xcc1a241e
+      CONSTRUCTOR_ALT = 0x3072cfa1
+
+      attr_reader :flags, :date, :expires, :test_mode, :this_dc, :dc_options
+
+      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
+
+      def self.parse(data)
+        constructor = data[0, 4].unpack1('L<')
+        raise UnexpectedConstructorError, constructor unless [CONSTRUCTOR, CONSTRUCTOR_ALT].include?(constructor)
+
+        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
+
+        offset += 4 # vector constructor
+        dc_count = data[offset, 4].unpack1('L<')
+        offset += 4
+
+        dc_options = []
+        dc_count.times do
+          dc_option, offset = parse_dc_option(data, offset)
+          dc_options << dc_option
+        end
+
+        new(
+          flags: flags, date: date, expires: expires,
+          test_mode: test_mode, this_dc: this_dc, dc_options: dc_options
+        )
+      end
+
+      class << self
+        private
+
+        def parse_dc_option(data, offset)
+          offset += 4 # constructor
+          flags = data[offset, 4].unpack1('L<')
+          offset += 4
+          id = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          ip_len = data.getbyte(offset)
+          offset += 1
+          ip_address = data[offset, ip_len]
+          offset += ip_len
+          padding = (4 - ((ip_len + 1) % 4)) % 4
+          offset += padding
+
+          port = data[offset, 4].unpack1('L<')
+          offset += 4
+
+          [{ id: id, ip_address: ip_address, port: port, flags: flags }, offset]
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/import_login_token.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class ImportLoginToken
+      include Binary
+
+      CONSTRUCTOR = 0x95ac5ce4
+
+      attr_reader :token
+
+      def initialize(token:)
+        @token = token
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) + serialize_tl_bytes(@token)
+      end
+
+      private
+
+      def serialize_tl_bytes(data)
+        bytes = data.bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/init_connection.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InitConnection
+      include Binary
+
+      CONSTRUCTOR = 0xc1cd5ea9
+
+      attr_reader :api_id, :device_model, :system_version, :app_version,
+        :system_lang_code, :lang_pack, :lang_code, :query
+
+      def initialize(api_id:, device_model:, system_version:, app_version:,
+                     system_lang_code:, lang_pack:, lang_code:, 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
+      end
+
+      def body
+        flags = 0
+
+        result = u32_b(CONSTRUCTOR)
+        result += u32_b(flags)
+        result += u32_b(@api_id)
+        result += serialize_tl_string(@device_model)
+        result += serialize_tl_string(@system_version)
+        result += serialize_tl_string(@app_version)
+        result += serialize_tl_string(@system_lang_code)
+        result += serialize_tl_string(@lang_pack)
+        result += serialize_tl_string(@lang_code)
+        result + @query.body
+      end
+
+      private
+
+      def serialize_tl_string(str)
+        bytes = str.encode('UTF-8').bytes
+        length = bytes.length
+
+        if length <= 253
+          [length] + bytes + padding(length + 1)
+        else
+          [254] + u32_b(length)[0, 3] + bytes + padding(length + 4)
+        end
+      end
+
+      def padding(current_length)
+        pad_length = (4 - (current_length % 4)) % 4
+        [0] * pad_length
+      end
+    end
+  end
+end

data/lib/mtproto/tl/objects/invoke_with_layer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    class InvokeWithLayer
+      include Binary
+
+      CONSTRUCTOR = 0xda9b0d0d
+
+      attr_reader :layer, :query
+
+      def initialize(layer:, query:)
+        @layer = layer
+        @query = query
+      end
+
+      def body
+        u32_b(CONSTRUCTOR) + u32_b(@layer) + @query.body
+      end
+    end
+  end
+end