Merge

Author: dolfies

discord/gateway.py

@@ -267,7 +267,7 @@ class DiscordWebSocket:
         shard_count: Optional[int]
         gateway: yarl.URL
         _max_heartbeat_timeout: float
-        _super_properties: Dict[str, Any]
+        _headers: utils.Headers
         _transport_compression: bool
 
     # fmt: off
@@ -315,6 +315,7 @@ def __init__(self, socket: WebSocket, *, loop: asyncio.AbstractEventLoop) -> Non
         self._hello_trace: List[str] = []
         self._session_trace: List[str] = []
         self._resume_trace: List[str] = []
+        self._initial_identify: bool = False
 
         # Presence state tracking
         self.afk: bool = False
@@ -380,7 +381,7 @@ async def from_client(
         ws.session_id = session
         ws.sequence = sequence
         ws._max_heartbeat_timeout = client._connection.heartbeat_timeout
-        ws._super_properties = client.http.headers.super_properties
+        ws._headers = client.http.headers
         ws._transport_compression = compress
         ws.afk = client._connection._afk
         ws.idle_since = client._connection._idle_since
@@ -454,31 +455,30 @@ async def identify(self) -> None:
         #     presence['status'] = self._connection._status or 'unknown'
         #     presence['activities'] = self._connection._activities
 
-        # TODO: Implement client state
+        properties = self._headers.gateway_properties
+        if not self._initial_identify:
+            # As of right now, the first IDENTIFY in the client is missing
+            # client_heartbeat_session_id because of weird codepaths
+            properties.pop('client_heartbeat_session_id', None)
+
         payload = {
             'op': self.IDENTIFY,
             'd': {
                 'token': self.token,
                 'capabilities': self.capabilities.value,
-                'properties': self._super_properties,
+                'properties': properties,
                 'presence': presence,
                 'compress': not self._transport_compression,  # We require at least one form of compression
                 'client_state': {
-                    'api_code_version': 0,
                     'guild_versions': {},
-                    # 'highest_last_message_id': '0',
-                    # 'initial_guild_id': None,
-                    # 'private_channels_version': '0',
-                    # 'read_state_version': 0,
-                    # 'user_guild_settings_version': -1,
-                    # 'user_settings_version': -1,
                 },
             },
         }
 
         await self.call_hooks('before_identify', initial=self._initial_identify)
         await self.send_as_json(payload)
         _log.debug('Gateway has sent the IDENTIFY payload.')
+        self._initial_identify = True
 
     async def resume(self) -> None:
         """Sends the RESUME packet."""

discord/utils.py

@@ -79,6 +79,7 @@
 import struct
 import time
 import yarl
+import uuid
 
 try:
     import orjson  # type: ignore
@@ -1740,27 +1741,30 @@ class Headers:
     """
 
     FALLBACK_BUILD_NUMBER = 9999
-    FALLBACK_BROWSER_VERSION = 135
+    FALLBACK_BROWSER_VERSION = 136
 
     def __init__(
         self,
+        *,
         platform: Literal['Windows', 'macOS', 'Linux', 'Android', 'iOS'],
         major_version: int,
         super_properties: Dict[str, Any],
         encoded_super_properties: str,
+        extra_gateway_properties: Optional[Dict[str, Any]] = None,
     ) -> None:
         self.platform = platform
         self.major_version = major_version
         self.super_properties = super_properties
         self.encoded_super_properties = encoded_super_properties
+        self.extra_gateway_properties = extra_gateway_properties or {}
 
     @classmethod
     async def default(
         cls: type[Self], session: ClientSession
     ) -> Self:
         """Creates a new :class:`Headers` instance using the default fetching mechanisms."""
         try:
-            properties, encoded = await asyncio.wait_for(
+            properties, extra, encoded = await asyncio.wait_for(
                 cls.get_api_properties(session, 'web'), timeout=3
             )
         except Exception:
@@ -1771,6 +1775,7 @@ async def default(
                 major_version=int(properties['browser_version'].split('.')[0]),
                 super_properties=properties,
                 encoded_super_properties=encoded,
+                extra_gateway_properties=extra,
             )
 
         try:
@@ -1789,6 +1794,7 @@ async def default(
             'os': 'Windows',
             'browser': 'Chrome',
             'device': '',
+            'system_locale': 'en-US',
             'browser_user_agent': cls._get_user_agent(bv),
             'browser_version': f'{bv}.0.0.0',
             'os_version': '10',
@@ -1797,42 +1803,56 @@ async def default(
             'referrer_current': '',
             'referring_domain_current': '',
             'release_channel': 'stable',
-            'system_locale': 'en-US',
             'client_build_number': bn,
             'client_event_source': None,
             'has_client_mods': False,
+            'client_heartbeat_session_id': str(uuid.uuid4()),
         }
 
         return cls(
             platform='Windows',
             major_version=bv,
             super_properties=properties,
             encoded_super_properties=b64encode(_to_json(properties).encode()).decode('utf-8'),
+            extra_gateway_properties={
+                'client_app_state': None,
+                'is_fast_connect': False,
+            },
         )
 
     @cached_property
     def user_agent(self) -> str:
+        """Returns the user agent to be used for HTTP requests."""
         return self.super_properties['browser_user_agent']
 
     @cached_property
     def client_hints(self) -> Dict[str, str]:
+        """Returns the client hints to be used for HTTP requests."""
         return {
             'Sec-CH-UA': ', '.join([f'"{brand}";v="{version}"' for brand, version in self.generate_brand_version_list()]),
             'Sec-CH-UA-Mobile': '?1' if self.platform in ('Android', 'iOS') else '?0',
             'Sec-CH-UA-Platform': f'"{self.platform}"',
         }
 
+    @property
+    def gateway_properties(self) -> Dict[str, Any]:
+        """Returns the properties to be used for the Gateway."""
+        return {
+            **self.super_properties,
+            **self.extra_gateway_properties,
+        }
+
     @staticmethod
     async def get_api_properties(
         session: ClientSession, type: str
-    ) -> Tuple[Dict[str, Any], str]:
+    ) -> Tuple[Dict[str, Any], Dict[str, Any], str]:
         """Fetches client properties from the API."""
         async with session.post(
             f'https://cordapi.dolfi.es/api/v2/properties/{type}'
         ) as resp:
             resp.raise_for_status()
             json = await resp.json()
-            return json['properties'], json['encoded']
+            return json['properties'], json['extra_gateway_properties'], json['encoded']
 
     @staticmethod
     async def _get_build_number(