mtproto 0.0.5 → 0.0.7

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

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

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+
+module MTProto
+  module TL
+    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/tl/rpc/messages/updates.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module TL
+    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 == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+              offset = 4
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::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/tl/rpc/ping.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../serializer'
+
+module MTProto
+  module TL
+    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/tl/rpc/pong.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    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

data/lib/mtproto/tl/rpc/updates/difference.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module TL
+    module RPC
+      module Updates
+        class Difference
+          CONSTRUCTOR_DIFFERENCE = 0x00f49ca0
+          CONSTRUCTOR_DIFFERENCE_EMPTY = 0x5d75a138
+          CONSTRUCTOR_DIFFERENCE_SLICE = 0xa8fb1981
+          CONSTRUCTOR_DIFFERENCE_TOO_LONG = 0x4afe8f6d
+
+          # Updates constructors (can be returned instead of Difference)
+          CONSTRUCTOR_UPDATE_SHORT = 0x78d4dec1
+          CONSTRUCTOR_UPDATES = 0x74ae4240
+          CONSTRUCTOR_UPDATE_SHORT_MESSAGE = 0x313bc7f8
+          CONSTRUCTOR_UPDATE_SHORT_CHAT_MESSAGE = 0x402d5dbb
+          CONSTRUCTOR_UPDATE_SHORT_SENT_MESSAGE = 0x11f1331c
+
+          VECTOR_CONSTRUCTOR = 0x1cb5c415
+          MESSAGE_CONSTRUCTOR = 0x452c0e65
+          MESSAGE_EMPTY_CONSTRUCTOR = 0x83e5de54
+
+          def self.parse(response)
+            offset = 0
+
+            constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+              offset = 4
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::RpcError.deserialize(response)
+              raise MTProto::RpcError.new(error.error_code, error.error_message)
+            end
+
+            case constructor
+            when CONSTRUCTOR_DIFFERENCE_EMPTY
+              # updates.differenceEmpty#5d75a138 date:int seq:int = updates.Difference;
+              date = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              seq = response[offset, 4].unpack1('L<')
+
+              {
+                type: :empty,
+                date: date,
+                seq: seq,
+                new_messages: [],
+                state: nil
+              }
+
+            when CONSTRUCTOR_DIFFERENCE, CONSTRUCTOR_DIFFERENCE_SLICE
+              # updates.difference#f49ca0 new_messages:Vector<Message> new_encrypted_messages:Vector<EncryptedMessage> other_updates:Vector<Update> chats:Vector<Chat> users:Vector<User> state:updates.State = updates.Difference;
+              # updates.differenceSlice#a8fb1981 new_messages:Vector<Message> new_encrypted_messages:Vector<EncryptedMessage> other_updates:Vector<Update> chats:Vector<Chat> users:Vector<User> intermediate_state:updates.State = updates.Difference;
+
+              # Parse new_messages vector
+              messages, offset = parse_messages_vector(response, offset)
+
+              # Skip new_encrypted_messages vector
+              offset = skip_vector(response, offset)
+
+              # Skip other_updates vector
+              offset = skip_vector(response, offset)
+
+              # Skip chats vector
+              offset = skip_vector(response, offset)
+
+              # Parse users vector
+              users, offset = parse_users_vector(response, offset)
+
+              {
+                type: constructor == CONSTRUCTOR_DIFFERENCE ? :difference : :slice,
+                new_messages: messages,
+                users: users,
+                state: nil # Would need to parse state
+              }
+
+            when CONSTRUCTOR_DIFFERENCE_TOO_LONG
+              # updates.differenceTooLong#4afe8f6d pts:int = updates.Difference;
+              pts = response[offset, 4].unpack1('L<')
+
+              {
+                type: :too_long,
+                pts: pts,
+                new_messages: [],
+                state: nil
+              }
+
+            when CONSTRUCTOR_UPDATE_SHORT_MESSAGE
+              # updateShortMessage#313bc7f8 flags:# out:flags.1?true mentioned:flags.4?true media_unread:flags.5?true silent:flags.13?true id:int user_id:long message:string pts:int pts_count:int date:int fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?long reply_to:flags.3?MessageReplyHeader entities:flags.7?Vector<MessageEntity> ttl_period:flags.25?int = Updates;
+
+              flags = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              id = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              user_id = response[offset, 8].unpack1('Q<')
+              offset += 8
+
+              # Parse message string
+              msg_len = response[offset].unpack1('C')
+              offset += 1
+              message_text = response[offset, msg_len].force_encoding('UTF-8')
+              offset += msg_len
+              padding = (4 - ((1 + msg_len) % 4)) % 4
+              offset += padding
+
+              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
+
+              # Return with the extracted message
+              {
+                type: :short_message,
+                new_messages: [{
+                  id: id,
+                  user_id: user_id,
+                  date: date,
+                  message: message_text,
+                  flags: flags
+                }],
+                state: { pts: pts, pts_count: pts_count }
+              }
+
+            when CONSTRUCTOR_UPDATE_SHORT, CONSTRUCTOR_UPDATES,
+                 CONSTRUCTOR_UPDATE_SHORT_CHAT_MESSAGE,
+                 CONSTRUCTOR_UPDATE_SHORT_SENT_MESSAGE
+              # Sometimes getDifference returns Updates instead of Difference
+              # This means there are no new differences, treat as empty
+              {
+                type: :empty,
+                date: Time.now.to_i,
+                seq: 0,
+                new_messages: [],
+                state: nil
+              }
+
+            else
+              # Unknown constructor - likely an Updates variant we don't handle yet
+              # Treat as empty to avoid breaking the polling loop
+              warn "Warning: Unknown Difference/Updates constructor: 0x#{constructor.to_s(16)}, treating as empty"
+              {
+                type: :empty,
+                date: Time.now.to_i,
+                seq: 0,
+                new_messages: [],
+                state: nil
+              }
+            end
+          end
+
+          def self.parse_messages_vector(response, offset)
+            # Check for Vector constructor
+            vector_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return [[], offset] unless vector_constructor == VECTOR_CONSTRUCTOR
+
+            count = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            messages = []
+            count.times do
+              message, offset = parse_message(response, offset)
+              messages << message if message
+            end
+
+            [messages, offset]
+          end
+
+          def self.parse_message(response, offset)
+            msg_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return [nil, offset] if msg_constructor == MESSAGE_EMPTY_CONSTRUCTOR
+
+            return [nil, offset] unless msg_constructor == MESSAGE_CONSTRUCTOR
+
+            # message#452c0e65 flags:# out:flags.1?true mentioned:flags.4?true media_unread:flags.5?true silent:flags.13?true post:flags.14?true from_scheduled:flags.18?true legacy:flags.19?true edit_hide:flags.21?true pinned:flags.24?true noforwards:flags.26?true invert_media:flags.27?true offline:flags.30?true id:int from_id:flags.8?Peer from_boosts_applied:flags.29?int peer_id:Peer fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?long reply_to:flags.3?MessageReplyHeader date:int message:string media:flags.9?MessageMedia reply_markup:flags.6?ReplyMarkup entities:flags.7?Vector<MessageEntity> views:flags.10?int forwards:flags.10?int replies:flags.23?MessageReplies edit_date:flags.15?int post_author:flags.16?string grouped_id:flags.17?long reactions:flags.20?MessageReactions restriction_reason:flags.22?Vector<RestrictionReason> ttl_period:flags.25?int quick_reply_shortcut_id:flags.30?int effect:flags.31?long = Message;
+
+            flags = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            # For simplicity, we'll just extract id, date, and message text
+            # A full implementation would parse all fields based on flags
+
+            id = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            # Skip from_id if present (flags.8)
+            if (flags & (1 << 8)) != 0
+              # Skip Peer object (constructor + id, could be user/chat/channel)
+              offset += 4 # peer constructor
+              offset += 8 # peer id (long for user, int for others, but let's assume worst case)
+            end
+
+            # Skip from_boosts_applied if present (flags.29)
+            offset += 4 if (flags & (1 << 29)) != 0
+
+            # peer_id:Peer (always present) - skip it
+            offset += 4 # peer constructor
+            offset += 8 # peer id
+
+            # Skip fwd_from if present (flags.2)
+            # This is complex, so we'll just skip ahead assuming it's not there for now
+
+            # Skip via_bot_id if present (flags.11)
+            offset += 8 if (flags & (1 << 11)) != 0
+
+            # Skip reply_to if present (flags.3)
+            # Complex object, skip for now
+
+            # date:int (always present)
+            date = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            # message:string (always present)
+            msg_len = response[offset].unpack1('C')
+            offset += 1
+            message_text = response[offset, msg_len].force_encoding('UTF-8')
+            offset += msg_len
+            padding = (4 - ((1 + msg_len) % 4)) % 4
+            offset += padding
+
+            # Return simplified message
+            [{
+              id: id,
+              date: date,
+              message: message_text,
+              flags: flags
+            }, offset]
+          rescue StandardError => e
+            # If parsing fails, skip this message
+            [nil, offset]
+          end
+
+          def self.skip_vector(response, offset)
+            # Read vector constructor
+            vector_constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            return offset unless vector_constructor == VECTOR_CONSTRUCTOR
+
+            # Read count
+            count = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            # Skip each element - we can't know the size, so return offset as-is
+            # This is a limitation - proper skipping would require parsing each element
+            # For now, just read the constructor of each element and skip based on known patterns
+            count.times do
+              constructor = response[offset, 4].unpack1('L<')
+              offset += 4
+
+              # This is a simplified skip - real implementation would need to parse each type
+              # For now, skip a reasonable amount (most TL objects are small)
+              # This is fragile but works for common cases
+            end
+
+            offset
+          end
+
+          def self.parse_users_vector(response, offset)
+            # Check for Vector constructor
+            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
+
+            # id:long (always present)
+            user_id = response[offset, 8].unpack1('Q<')
+            offset += 8
+
+            # access_hash:flags.0?long (conditional)
+            access_hash = nil
+            if (flags & (1 << 0)) != 0
+              access_hash = response[offset, 8].unpack1('Q<')
+              offset += 8
+            end
+
+            # We have what we need, skip the rest
+            [{
+              id: user_id,
+              access_hash: access_hash
+            }, offset]
+          rescue StandardError => e
+            [nil, offset]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtproto/tl/rpc/updates/get_difference.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../../serializer'
+
+module MTProto
+  module TL
+    module RPC
+      module Updates
+        class GetDifference
+          CONSTRUCTOR = 0x19c2f763
+
+          def self.build(pts:, pts_limit:, pts_total_limit: nil, date:, qts:, qts_limit: nil)
+            raise ArgumentError, 'pts is required' if pts.nil?
+            raise ArgumentError, 'date is required' if date.nil?
+            raise ArgumentError, 'qts is required' if qts.nil?
+
+            # updates.getDifference#19c2f763 flags:# pts:int pts_limit:flags.0?int pts_total_limit:flags.1?int date:int qts:int qts_limit:flags.2?int = updates.Difference;
+            flags = 0
+            flags |= (1 << 0) if pts_limit
+            flags |= (1 << 1) if pts_total_limit
+            flags |= (1 << 2) if qts_limit
+
+            query = [CONSTRUCTOR].pack('L<')
+            query += Serializer.serialize_int(flags)
+            query += Serializer.serialize_int(pts)
+
+            query += Serializer.serialize_int(pts_limit) if pts_limit
+
+            query += Serializer.serialize_int(pts_total_limit) if pts_total_limit
+
+            query += Serializer.serialize_int(date)
+            query += Serializer.serialize_int(qts)
+
+            query += Serializer.serialize_int(qts_limit) if qts_limit
+
+            query
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../gzip_packed'
+require_relative '../../rpc_error'
+
+module MTProto
+  module TL
+    module RPC
+      module Updates
+        class State
+          CONSTRUCTOR = 0xa56c2a3e
+
+          def self.parse(response)
+            offset = 0
+
+            constructor = response[offset, 4].unpack1('L<')
+            offset += 4
+
+            if constructor == TL::GzipPacked::CONSTRUCTOR
+              response = TL::GzipPacked.unpack(response)
+              constructor = response[0, 4].unpack1('L<')
+              offset = 4
+            end
+
+            if constructor == TL::RpcError::CONSTRUCTOR
+              error = TL::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/tl/rpc/users/get_users.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module MTProto
+  module TL
+    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