mtproto 0.0.6 → 0.0.8

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

@@ -0,0 +1,155 @@
+# 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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module RPC
+      module Contacts
+        class GetContacts
+          def self.build(hash: 0)
+            # contacts.getContacts#22c6aa08 hash:int = contacts.Contacts;
+            data = [0x22c6aa08].pack('L<')
+            data += [hash].pack('l<')
+            data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/rpc/help/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+require_relative '../../config'
+
+module MTProto
+  module Type
+    module RPC
+      module Help
+        class Config
+          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::Config::CONSTRUCTOR || constructor == Type::Config::CONSTRUCTOR_ALT
+              Type::Config.deserialize(response)
+            else
+              raise UnexpectedConstructorError.new(constructor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/rpc/help/get_config.rb

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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module Type
+    module RPC
+      class InitConnection
+        CONSTRUCTOR = 0xc1cd5ea9
+
+        def self.build(api_id:, device_model:, system_version:, app_version:, system_lang_code:, lang_pack:, lang_code:, query:)
+          flags = 0
+
+          body = [CONSTRUCTOR].pack('L<')
+          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
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module Type
+    module RPC
+      class InvokeWithLayer
+        CONSTRUCTOR = 0xda9b0d0d
+
+        def self.build(layer:, query:)
+          body = [CONSTRUCTOR].pack('L<')
+          body += Serializer.serialize_int(layer)
+          body + query
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/type/rpc/messages/send_message.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+
+module MTProto
+  module Type
+    module RPC
+      module Messages
+        class SendMessage
+          CONSTRUCTOR = 0xfe05dc9a
+          INPUT_PEER_USER = 0xdde8a54c
+
+          def self.build(user_id:, access_hash:, message:, random_id: nil)
+            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?
+
+            random_id ||= SecureRandom.random_number(2**63)
+
+            query = [CONSTRUCTOR].pack('L<')
+
+            # flags:# (no optional fields for now)
+            flags = 0
+            query += Serializer.serialize_int(flags)
+
+            # peer:InputPeer (inputPeerUser)
+            query += [INPUT_PEER_USER].pack('L<')
+            query += Serializer.serialize_long(user_id)
+            query += Serializer.serialize_long(access_hash)
+
+            # message:string
+            query += Serializer.serialize_string(message)
+
+            # random_id:long
+            query += Serializer.serialize_long(random_id)
+
+            query
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module Type
+    module RPC
+      module Messages
+        class Updates
+          CONSTRUCTOR_UPDATES = 0x74ae4240
+          CONSTRUCTOR_UPDATE_SHORT = 0x78d4dec1
+          CONSTRUCTOR_UPDATE_SHORT_MESSAGE = 0x313bc7f8
+          CONSTRUCTOR_UPDATE_SHORT_CHAT_MESSAGE = 0x4d6deea5
+          CONSTRUCTOR_UPDATE_SHORT_SENT_MESSAGE = 0x9015e101
+
+          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_UPDATE_SHORT_SENT_MESSAGE
+              # updateShortSentMessage#11f1331c flags:# out:flags.1?true id:int pts:int pts_count:int date:int media:flags.9?MessageMedia entities:flags.7?Vector<MessageEntity> ttl_period:flags.25?int = Updates;
+              flags = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              message_id = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              pts = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              pts_count = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              date = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              {
+                sent: true,
+                message_id: message_id,
+                date: date,
+                pts: pts,
+                pts_count: pts_count
+              }
+
+            when CONSTRUCTOR_UPDATE_SHORT_MESSAGE, CONSTRUCTOR_UPDATE_SHORT_CHAT_MESSAGE
+              # updateShortMessage#2296d2c8 or updateShortChatMessage#402d5dbb
+              # Both have similar structure with flags, id, etc.
+              flags = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              message_id = response[offset, 4].unpack1('L<')
+
+              {
+                sent: true,
+                message_id: message_id
+              }
+
+            when CONSTRUCTOR_UPDATES, CONSTRUCTOR_UPDATE_SHORT
+              # For full updates or updateShort, just confirm success
+              {
+                sent: true
+              }
+
+            else
+              raise "Unknown Updates constructor: 0x#{constructor.to_s(16)}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module Type
+    module RPC
+      class Ping
+        CONSTRUCTOR = 0x7abe77ec
+
+        def self.build(ping_id)
+          body = Serializer.serialize_int(CONSTRUCTOR)
+          body + [ping_id].pack('Q<')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module Type
+    module RPC
+      class Pong
+        CONSTRUCTOR = 0x347773c5
+        CONSTRUCTOR_BAD_MSG_NOTIFICATION = 0xa7eff811
+
+        def self.parse(body)
+          constructor = body[0, 4].unpack1('L<')
+
+          if constructor == CONSTRUCTOR_BAD_MSG_NOTIFICATION
+            bad_msg = 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 == MsgContainer::CONSTRUCTOR
+            container = MsgContainer.deserialize(body)
+            pong_message = container.messages.find do |msg|
+              msg[:body][0, 4].unpack1('L<') == CONSTRUCTOR
+            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
+
+          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
+      end
+    end
+  end
+end