chore(logout): add extensive logging to diagnose deep-link issue

rodrigo-fournier-immutable · rodrigo-fournier-immutable · commit 239d3504a54c · 2026-02-04T15:56:48.000+11:00
Add comprehensive logging throughout logout flow to identify why
deep-link callback is not triggered after browser logout.

This will help identify if the issue is:
- Deep-link not being written to registry by browser
- Deep-link not being read from registry by Unity
- Deep-link not matching expected logout URI
- Callback not being invoked after deeplink receipt
diff --git a/src/Packages/Passport/Runtime/Scripts/Private/Helpers/WindowsDeepLink.cs b/src/Packages/Passport/Runtime/Scripts/Private/Helpers/WindowsDeepLink.cs
@@ -82,22 +82,37 @@ private static extern int RegQueryValueEx(
         /// <param name="callback">Callback to invoke when a deep link is received</param>
         public static void Initialise(string redirectUri, Action<string> callback)
         {
+            PassportLogger.Info($"[WindowsDeepLink] ===== INITIALISE CALLED =====");
+            PassportLogger.Info($"[WindowsDeepLink] redirectUri: {redirectUri}");
+            PassportLogger.Info($"[WindowsDeepLink] callback: {(callback == null ? "NULL" : "PROVIDED")}");
+            PassportLogger.Info($"[WindowsDeepLink] _instance: {(_instance == null ? "NULL - will create new" : "EXISTS - will reuse")}");
+            
             if (_instance == null)
             {
                 _instance = new GameObject(nameof(WindowsDeepLink)).AddComponent<WindowsDeepLink>();
                 DontDestroyOnLoad(_instance.gameObject);
+                PassportLogger.Info($"[WindowsDeepLink] Created new WindowsDeepLink GameObject");
             }
 
-            if (string.IsNullOrEmpty(redirectUri)) return;
+            if (string.IsNullOrEmpty(redirectUri))
+            {
+                PassportLogger.Warn($"[WindowsDeepLink] redirectUri is null or empty! Returning early.");
+                return;
+            }
 
             // Extract protocol name from URI (e.g. "immutable" from "immutable://")
             var protocolName = redirectUri.Split(new[] { "://" }, StringSplitOptions.None)[0];
+            PassportLogger.Info($"[WindowsDeepLink] Extracted protocol name: '{protocolName}'");
+            
             _instance._protocolName = protocolName;
             _instance._callback = callback;
 
             // Register protocol and create handler script
+            PassportLogger.Info($"[WindowsDeepLink] Registering protocol '{protocolName}'...");
             RegisterProtocol(protocolName);
+            PassportLogger.Info($"[WindowsDeepLink] Creating command script for protocol '{protocolName}'...");
             CreateCommandScript(protocolName);
+            PassportLogger.Info($"[WindowsDeepLink] ===== INITIALISE COMPLETED =====");
         }
 
         private static void CreateCommandScript(string protocolName)
@@ -341,9 +356,12 @@ private static string GetGameExecutablePath(string suffix)
 
         private void OnApplicationFocus(bool hasFocus)
         {
+            PassportLogger.Debug($"[WindowsDeepLink] OnApplicationFocus: hasFocus={hasFocus}");
+            
             // Only handle deeplink when application regains focus
             if (!hasFocus) return;
 
+            PassportLogger.Info($"[WindowsDeepLink] Application gained focus - checking for deeplink...");
             HandleDeeplink();
         }
 
@@ -356,11 +374,14 @@ private void Update()
             if (Time.unscaledTime < _nextPollAt) return;
             _nextPollAt = Time.unscaledTime + POLL_INTERVAL_SECONDS;
 
+            PassportLogger.Debug($"[WindowsDeepLink] Polling for deeplink (every {POLL_INTERVAL_SECONDS}s)...");
             HandleDeeplink();
         }
 
         private void HandleDeeplink()
         {
+            PassportLogger.Debug($"[WindowsDeepLink] HandleDeeplink called - checking registry for protocol '{_protocolName}'");
+            
             // Open registry key for the protocol
             var registryPath = $@"Software\Classes\{_protocolName}";
             UIntPtr hKey;
@@ -373,10 +394,12 @@ private void HandleDeeplink()
 
             if (result != 0)
             {
-                PassportLogger.Error($"Failed to open registry key. Error code: {result}");
+                PassportLogger.Error($"[WindowsDeepLink] Failed to open registry key '{registryPath}'. Error code: {result}");
                 return;
             }
 
+            PassportLogger.Debug($"[WindowsDeepLink] Successfully opened registry key '{registryPath}'");
+
             // Get size of deeplink data
             uint type = 0;
             uint dataSize = 0;
@@ -388,11 +411,17 @@ private void HandleDeeplink()
                 // No deeplink written yet; don't spam logs on each poll.
                 if (result != ERROR_FILE_NOT_FOUND)
                 {
-                    PassportLogger.Warn($"Failed to get deeplink data size. Error code: {result}");
+                    PassportLogger.Warn($"[WindowsDeepLink] Failed to get deeplink data size from registry. Error code: {result}");
+                }
+                else
+                {
+                    PassportLogger.Debug($"[WindowsDeepLink] No deeplink found in registry yet (ERROR_FILE_NOT_FOUND)");
                 }
                 return;
             }
 
+            PassportLogger.Info($"[WindowsDeepLink] ✓ Found deeplink in registry! dataSize={dataSize}");
+
             // Read deeplink data
             var data = new byte[dataSize];
             result = RegQueryValueEx(hKey, REGISTRY_DEEP_LINK_NAME, IntPtr.Zero, ref type, data, ref dataSize);
@@ -402,20 +431,24 @@ private void HandleDeeplink()
             {
                 // Convert and validate URI
                 var uri = System.Text.Encoding.Unicode.GetString(data, 0, (int)dataSize - 2); // Remove null terminator
+                PassportLogger.Info($"[WindowsDeepLink] Read deeplink URI from registry: '{uri}'");
+                
                 if (_protocolName != null && !uri.StartsWith(_protocolName))
                 {
-                    PassportLogger.Error($"Incorrect prefix uri {uri}");
+                    PassportLogger.Error($"[WindowsDeepLink] ✗ Incorrect protocol prefix! Expected '{_protocolName}://' but got '{uri}'");
                 }
                 else
                 {
                     // Invoke callback with valid URI
+                    PassportLogger.Info($"[WindowsDeepLink] ✓ Valid URI - invoking callback...");
                     _callback?.Invoke(uri);
                     callbackInvoked = true;
+                    PassportLogger.Info($"[WindowsDeepLink] Callback invoked successfully");
                 }
             }
             else
             {
-                PassportLogger.Warn($"Failed to get registry key. Error code: {result}");
+                PassportLogger.Warn($"[WindowsDeepLink] Failed to read deeplink from registry. Error code: {result}, type: {type}");
             }
 
             // Clean up registry handle
@@ -424,37 +457,41 @@ private void HandleDeeplink()
             // Delete registry key if callback was invoked
             if (callbackInvoked)
             {
+                PassportLogger.Info($"[WindowsDeepLink] Deleting registry key '{registryPath}'...");
                 result = RegDeleteTree((UIntPtr)HKEY_CURRENT_USER, registryPath);
 
                 if (result != 0)
                 {
-                    PassportLogger.Warn($"Failed to delete registry key. Error code: {result}");
+                    PassportLogger.Warn($"[WindowsDeepLink] Failed to delete registry key. Error code: {result}");
                 }
                 else
                 {
-                    PassportLogger.Debug("Successfully deleted registry key.");
+                    PassportLogger.Info($"[WindowsDeepLink] Successfully deleted registry key.");
                 }
             }
             else
             {
-                PassportLogger.Debug("Did not invoke callback so not deleting registry key.");
+                PassportLogger.Debug($"[WindowsDeepLink] Did not invoke callback so not deleting registry key.");
             }
 
             // Clean up command script
             var cmdPath = GetGameExecutablePath(".cmd");
             if (File.Exists(cmdPath))
             {
+                PassportLogger.Info($"[WindowsDeepLink] Deleting command script: {cmdPath}");
                 try
                 {
                     File.Delete(cmdPath);
+                    PassportLogger.Info($"[WindowsDeepLink] Command script deleted successfully");
                 }
                 catch (Exception ex)
                 {
-                    PassportLogger.Warn($"Failed to delete script: {ex.Message}");
+                    PassportLogger.Warn($"[WindowsDeepLink] Failed to delete script: {ex.Message}");
                 }
             }
 
             // Clean up instance
+            PassportLogger.Info($"[WindowsDeepLink] Destroying WindowsDeepLink GameObject and clearing instance");
             Destroy(gameObject);
             _instance = null;
         }
diff --git a/src/Packages/Passport/Runtime/Scripts/Private/PassportImpl.cs b/src/Packages/Passport/Runtime/Scripts/Private/PassportImpl.cs
@@ -251,30 +251,51 @@ public async void OnDeepLinkActivated(string url)
         {
             try
             {
+                PassportLogger.Info($"{TAG} ===== DEEPLINK RECEIVED =====");
                 PassportLogger.Info($"{TAG} Received deeplink URL: {url}");
+                PassportLogger.Info($"{TAG} _redirectUri={_redirectUri}, _logoutRedirectUri={_logoutRedirectUri}");
 
                 Uri uri = new Uri(url);
                 string hostWithPort = uri.IsDefaultPort ? uri.Host : $"{uri.Host}:{uri.Port}";
 
                 string domain = $"{uri.Scheme}://{hostWithPort}{uri.AbsolutePath}";
+                
+                PassportLogger.Info($"{TAG} Parsed domain from deeplink: {domain}");
 
                 if (domain.EndsWith("/"))
                 {
                     domain = domain.Remove(domain.Length - 1);
+                    PassportLogger.Info($"{TAG} Removed trailing slash from domain: {domain}");
                 }
 
+                PassportLogger.Info($"{TAG} Comparing domain '{domain}' with:");
+                PassportLogger.Info($"{TAG}   - _logoutRedirectUri: '{_logoutRedirectUri}'");
+                PassportLogger.Info($"{TAG}   - _redirectUri: '{_redirectUri}'");
+
                 if (domain.Equals(_logoutRedirectUri))
                 {
+                    PassportLogger.Info($"{TAG} ✓ LOGOUT deeplink match! Calling HandleLogoutPkceSuccess...");
                     HandleLogoutPkceSuccess();
                 }
                 else if (domain.Equals(_redirectUri))
                 {
+                    PassportLogger.Info($"{TAG} ✓ LOGIN deeplink match! Calling CompleteLoginPKCEFlow...");
                     await CompleteLoginPKCEFlow(url);
                 }
+                else
+                {
+                    PassportLogger.Warn($"{TAG} ✗ Deeplink does NOT match logout or login URI!");
+                    PassportLogger.Warn($"{TAG}   Received: '{domain}'");
+                    PassportLogger.Warn($"{TAG}   Expected logout: '{_logoutRedirectUri}' OR login: '{_redirectUri}'");
+                }
+                
+                PassportLogger.Info($"{TAG} ===== DEEPLINK PROCESSING COMPLETED =====");
             }
             catch (Exception ex)
             {
-                PassportLogger.Error($"{TAG} Deeplink error {url}: {ex.Message}");
+                PassportLogger.Error($"{TAG} ===== DEEPLINK ERROR =====");
+                PassportLogger.Error($"{TAG} Deeplink error for URL {url}: {ex.Message}");
+                PassportLogger.Error($"{TAG} Stack trace: {ex.StackTrace}");
             }
         }
 
@@ -454,20 +475,30 @@ public async UniTask<bool> Logout(bool hardLogout = true)
         {
             try
             {
+                PassportLogger.Info($"{TAG} ===== LOGOUT FLOW START =====");
+                PassportLogger.Info($"{TAG} hardLogout={hardLogout}, _logoutRedirectUri={_logoutRedirectUri}");
+                
                 SendAuthEvent(PassportAuthEvent.LoggingOutPKCE);
 
                 var task = new UniTaskCompletionSource<bool>();
                 _pkceCompletionSource = task;
+                
+                PassportLogger.Info($"{TAG} Created _pkceCompletionSource for logout");
+                
 #if UNITY_STANDALONE_WIN || (UNITY_ANDROID && UNITY_EDITOR_WIN) || (UNITY_IPHONE && UNITY_EDITOR_WIN)
+                PassportLogger.Info($"{TAG} Initialising WindowsDeepLink for logout with URI: {_logoutRedirectUri}");
                 WindowsDeepLink.Initialise(_logoutRedirectUri, OnDeepLinkActivated);
+                PassportLogger.Info($"{TAG} WindowsDeepLink.Initialise completed");
 #endif
                 LaunchLogoutPkceUrl(hardLogout);
+                PassportLogger.Info($"{TAG} Waiting for logout callback (deep-link or completion)...");
                 return await task.Task;
             }
             catch (Exception ex)
             {
                 var errorMessage = $"Failed to log out: {ex.Message}";
                 PassportLogger.Error($"{TAG} {errorMessage}");
+                PassportLogger.Error($"{TAG} Stack trace: {ex.StackTrace}");
 
                 Track(PassportAnalytics.EventName.COMPLETE_LOGOUT_PKCE, success: false);
                 SendAuthEvent(PassportAuthEvent.LogoutPKCEFailed);
@@ -477,30 +508,53 @@ public async UniTask<bool> Logout(bool hardLogout = true)
 
         private async void HandleLogoutPkceSuccess()
         {
+            PassportLogger.Info($"{TAG} ===== HANDLE LOGOUT SUCCESS CALLED =====");
+            PassportLogger.Info($"{TAG} _isLoggedIn={_isLoggedIn}, _pkceCompletionSource={(_pkceCompletionSource == null ? "NULL" : "EXISTS")}");
+            
             await UniTask.SwitchToMainThread();
+            
+            PassportLogger.Info($"{TAG} Switched to main thread");
+            
             if (_isLoggedIn)
             {
+                PassportLogger.Info($"{TAG} User was logged in, setting PKCE result to true");
                 TrySetPkceResult(true);
             }
+            else
+            {
+                PassportLogger.Warn($"{TAG} User was NOT logged in when HandleLogoutPkceSuccess was called!");
+            }
+            
             Track(PassportAnalytics.EventName.COMPLETE_LOGOUT_PKCE, success: true);
             SendAuthEvent(PassportAuthEvent.LogoutPKCESuccess);
+            
             _isLoggedIn = false;
             _pkceCompletionSource = null;
+            
+            PassportLogger.Info($"{TAG} ===== LOGOUT SUCCESS COMPLETED =====");
         }
 
         private async void LaunchLogoutPkceUrl(bool hardLogout)
         {
+            PassportLogger.Info($"{TAG} LaunchLogoutPkceUrl called with hardLogout={hardLogout}");
+            
             var logoutUrl = await GetLogoutUrl();
+            
+            PassportLogger.Info($"{TAG} Got logout URL: {logoutUrl}");
+            
             if (hardLogout)
             {
+                PassportLogger.Info($"{TAG} Performing hard logout - launching browser...");
 #if UNITY_ANDROID && !UNITY_EDITOR
                 LaunchAndroidUrl(logoutUrl);
 #else
                 _communicationsManager.LaunchAuthURL(logoutUrl, _logoutRedirectUri);
 #endif
+                PassportLogger.Info($"{TAG} Browser launched with logout URL. Waiting for deep-link callback...");
             }
             else
             {
+                PassportLogger.Info($"{TAG} Performing soft logout (no browser) - calling HandleLogoutPkceSuccess directly");
                 HandleLogoutPkceSuccess();
             }
         }
diff --git a/src/Packages/Passport/Runtime/Scripts/Public/Passport.cs b/src/Packages/Passport/Runtime/Scripts/Public/Passport.cs
@@ -628,12 +628,18 @@ private PassportImpl GetPassportImpl()
 
         private void OnDeepLinkActivated(string url)
         {
+            PassportLogger.Info($"{TAG} [Passport.OnDeepLinkActivated] Deeplink received: {url}");
             _deeplink = url;
 
             if (_passportImpl != null)
             {
+                PassportLogger.Info($"{TAG} [Passport.OnDeepLinkActivated] Forwarding to PassportImpl...");
                 GetPassportImpl().OnDeepLinkActivated(url);
             }
+            else
+            {
+                PassportLogger.Warn($"{TAG} [Passport.OnDeepLinkActivated] _passportImpl is NULL - cannot forward deeplink!");
+            }
         }
 
         private void OnPassportAuthEvent(PassportAuthEvent authEvent)
diff --git a/src/Packages/Passport/Samples~/SamplesScenesScripts/Scripts/Passport/Logout/LogoutScript.cs b/src/Packages/Passport/Samples~/SamplesScenesScripts/Scripts/Passport/Logout/LogoutScript.cs
@@ -22,14 +22,26 @@ private async UniTaskVoid LogoutAsync()
         }
         try
         {
+            Debug.Log($"[LogoutScript] ===== LOGOUT BUTTON CLICKED =====");
+            Debug.Log($"[LogoutScript] Starting logout process...");
+            
             await Passport.Instance.Logout();
+            
+            Debug.Log($"[LogoutScript] Logout completed successfully");
+            Debug.Log($"[LogoutScript] Setting connection flags to false...");
+            
             SampleAppManager.IsConnectedToImx = false;
             SampleAppManager.IsConnectedToZkEvm = false;
+            
+            Debug.Log($"[LogoutScript] Navigating to UnauthenticatedScene...");
             AuthenticatedSceneManager.NavigateToUnauthenticatedScene();
+            Debug.Log($"[LogoutScript] ===== LOGOUT FLOW COMPLETED =====");
         }
         catch (System.Exception ex)
         {
-            Debug.LogError($"Failed to logout: {ex.Message}");
+            Debug.LogError($"[LogoutScript] ===== LOGOUT FAILED =====");
+            Debug.LogError($"[LogoutScript] Failed to logout: {ex.Message}");
+            Debug.LogError($"[LogoutScript] Stack trace: {ex.StackTrace}");
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -82,22 +82,37 @@ private static extern int RegQueryValueEx(`
`82`	`82`	`/// <param name="callback">Callback to invoke when a deep link is received</param>`
`83`	`83`	`public static void Initialise(string redirectUri, Action<string> callback)`
`84`	`84`	`{`
	`85`	`+ PassportLogger.Info($"[WindowsDeepLink] ===== INITIALISE CALLED =====");`
	`86`	`+ PassportLogger.Info($"[WindowsDeepLink] redirectUri: {redirectUri}");`
	`87`	`+ PassportLogger.Info($"[WindowsDeepLink] callback: {(callback == null ? "NULL" : "PROVIDED")}");`
	`88`	`+ PassportLogger.Info($"[WindowsDeepLink] _instance: {(_instance == null ? "NULL - will create new" : "EXISTS - will reuse")}");`
	`89`	`+`
`85`	`90`	`if (_instance == null)`
`86`	`91`	`{`
`87`	`92`	`_instance = new GameObject(nameof(WindowsDeepLink)).AddComponent<WindowsDeepLink>();`
`88`	`93`	`DontDestroyOnLoad(_instance.gameObject);`
	`94`	`+ PassportLogger.Info($"[WindowsDeepLink] Created new WindowsDeepLink GameObject");`
`89`	`95`	`}`
`90`	`96`
`91`		`- if (string.IsNullOrEmpty(redirectUri)) return;`
	`97`	`+ if (string.IsNullOrEmpty(redirectUri))`
	`98`	`+ {`
	`99`	`+ PassportLogger.Warn($"[WindowsDeepLink] redirectUri is null or empty! Returning early.");`
	`100`	`+ return;`
	`101`	`+ }`
`92`	`102`
`93`	`103`	`// Extract protocol name from URI (e.g. "immutable" from "immutable://")`
`94`	`104`	`var protocolName = redirectUri.Split(new[] { "://" }, StringSplitOptions.None)[0];`
	`105`	`+ PassportLogger.Info($"[WindowsDeepLink] Extracted protocol name: '{protocolName}'");`
	`106`	`+`
`95`	`107`	`_instance._protocolName = protocolName;`
`96`	`108`	`_instance._callback = callback;`
`97`	`109`
`98`	`110`	`// Register protocol and create handler script`
	`111`	`+ PassportLogger.Info($"[WindowsDeepLink] Registering protocol '{protocolName}'...");`
`99`	`112`	`RegisterProtocol(protocolName);`
	`113`	`+ PassportLogger.Info($"[WindowsDeepLink] Creating command script for protocol '{protocolName}'...");`
`100`	`114`	`CreateCommandScript(protocolName);`
	`115`	`+ PassportLogger.Info($"[WindowsDeepLink] ===== INITIALISE COMPLETED =====");`
`101`	`116`	`}`
`102`	`117`
`103`	`118`	`private static void CreateCommandScript(string protocolName)`
`@@ -341,9 +356,12 @@ private static string GetGameExecutablePath(string suffix)`
`341`	`356`
`342`	`357`	`private void OnApplicationFocus(bool hasFocus)`
`343`	`358`	`{`
	`359`	`+ PassportLogger.Debug($"[WindowsDeepLink] OnApplicationFocus: hasFocus={hasFocus}");`
	`360`	`+`
`344`	`361`	`// Only handle deeplink when application regains focus`
`345`	`362`	`if (!hasFocus) return;`
`346`	`363`
	`364`	`+ PassportLogger.Info($"[WindowsDeepLink] Application gained focus - checking for deeplink...");`
`347`	`365`	`HandleDeeplink();`
`348`	`366`	`}`
`349`	`367`
`@@ -356,11 +374,14 @@ private void Update()`
`356`	`374`	`if (Time.unscaledTime < _nextPollAt) return;`
`357`	`375`	`_nextPollAt = Time.unscaledTime + POLL_INTERVAL_SECONDS;`
`358`	`376`
	`377`	`+ PassportLogger.Debug($"[WindowsDeepLink] Polling for deeplink (every {POLL_INTERVAL_SECONDS}s)...");`
`359`	`378`	`HandleDeeplink();`
`360`	`379`	`}`
`361`	`380`
`362`	`381`	`private void HandleDeeplink()`
`363`	`382`	`{`
	`383`	`+ PassportLogger.Debug($"[WindowsDeepLink] HandleDeeplink called - checking registry for protocol '{_protocolName}'");`
	`384`	`+`
`364`	`385`	`// Open registry key for the protocol`
`365`	`386`	`var registryPath = $@"Software\Classes\{_protocolName}";`
`366`	`387`	`UIntPtr hKey;`
`@@ -373,10 +394,12 @@ private void HandleDeeplink()`
`373`	`394`
`374`	`395`	`if (result != 0)`
`375`	`396`	`{`
`376`		`- PassportLogger.Error($"Failed to open registry key. Error code: {result}");`
	`397`	`+ PassportLogger.Error($"[WindowsDeepLink] Failed to open registry key '{registryPath}'. Error code: {result}");`
`377`	`398`	`return;`
`378`	`399`	`}`
`379`	`400`
	`401`	`+ PassportLogger.Debug($"[WindowsDeepLink] Successfully opened registry key '{registryPath}'");`
	`402`	`+`
`380`	`403`	`// Get size of deeplink data`
`381`	`404`	`uint type = 0;`
`382`	`405`	`uint dataSize = 0;`
`@@ -388,11 +411,17 @@ private void HandleDeeplink()`
`388`	`411`	`// No deeplink written yet; don't spam logs on each poll.`
`389`	`412`	`if (result != ERROR_FILE_NOT_FOUND)`
`390`	`413`	`{`
`391`		`- PassportLogger.Warn($"Failed to get deeplink data size. Error code: {result}");`
	`414`	`+ PassportLogger.Warn($"[WindowsDeepLink] Failed to get deeplink data size from registry. Error code: {result}");`
	`415`	`+ }`
	`416`	`+ else`
	`417`	`+ {`
	`418`	`+ PassportLogger.Debug($"[WindowsDeepLink] No deeplink found in registry yet (ERROR_FILE_NOT_FOUND)");`
`392`	`419`	`}`
`393`	`420`	`return;`
`394`	`421`	`}`
`395`	`422`
	`423`	`+ PassportLogger.Info($"[WindowsDeepLink] ✓ Found deeplink in registry! dataSize={dataSize}");`
	`424`	`+`
`396`	`425`	`// Read deeplink data`
`397`	`426`	`var data = new byte[dataSize];`
`398`	`427`	`result = RegQueryValueEx(hKey, REGISTRY_DEEP_LINK_NAME, IntPtr.Zero, ref type, data, ref dataSize);`
`@@ -402,20 +431,24 @@ private void HandleDeeplink()`
`402`	`431`	`{`
`403`	`432`	`// Convert and validate URI`
`404`	`433`	`var uri = System.Text.Encoding.Unicode.GetString(data, 0, (int)dataSize - 2); // Remove null terminator`
	`434`	`+ PassportLogger.Info($"[WindowsDeepLink] Read deeplink URI from registry: '{uri}'");`
	`435`	`+`
`405`	`436`	`if (_protocolName != null && !uri.StartsWith(_protocolName))`
`406`	`437`	`{`
`407`		`- PassportLogger.Error($"Incorrect prefix uri {uri}");`
	`438`	`+ PassportLogger.Error($"[WindowsDeepLink] ✗ Incorrect protocol prefix! Expected '{_protocolName}://' but got '{uri}'");`
`408`	`439`	`}`
`409`	`440`	`else`
`410`	`441`	`{`
`411`	`442`	`// Invoke callback with valid URI`
	`443`	`+ PassportLogger.Info($"[WindowsDeepLink] ✓ Valid URI - invoking callback...");`
`412`	`444`	`_callback?.Invoke(uri);`
`413`	`445`	`callbackInvoked = true;`
	`446`	`+ PassportLogger.Info($"[WindowsDeepLink] Callback invoked successfully");`
`414`	`447`	`}`
`415`	`448`	`}`
`416`	`449`	`else`
`417`	`450`	`{`
`418`		`- PassportLogger.Warn($"Failed to get registry key. Error code: {result}");`
	`451`	`+ PassportLogger.Warn($"[WindowsDeepLink] Failed to read deeplink from registry. Error code: {result}, type: {type}");`
`419`	`452`	`}`
`420`	`453`
`421`	`454`	`// Clean up registry handle`
`@@ -424,37 +457,41 @@ private void HandleDeeplink()`
`424`	`457`	`// Delete registry key if callback was invoked`
`425`	`458`	`if (callbackInvoked)`
`426`	`459`	`{`
	`460`	`+ PassportLogger.Info($"[WindowsDeepLink] Deleting registry key '{registryPath}'...");`
`427`	`461`	`result = RegDeleteTree((UIntPtr)HKEY_CURRENT_USER, registryPath);`
`428`	`462`
`429`	`463`	`if (result != 0)`
`430`	`464`	`{`
`431`		`- PassportLogger.Warn($"Failed to delete registry key. Error code: {result}");`
	`465`	`+ PassportLogger.Warn($"[WindowsDeepLink] Failed to delete registry key. Error code: {result}");`
`432`	`466`	`}`
`433`	`467`	`else`
`434`	`468`	`{`
`435`		`- PassportLogger.Debug("Successfully deleted registry key.");`
	`469`	`+ PassportLogger.Info($"[WindowsDeepLink] Successfully deleted registry key.");`
`436`	`470`	`}`
`437`	`471`	`}`
`438`	`472`	`else`
`439`	`473`	`{`
`440`		`- PassportLogger.Debug("Did not invoke callback so not deleting registry key.");`
	`474`	`+ PassportLogger.Debug($"[WindowsDeepLink] Did not invoke callback so not deleting registry key.");`
`441`	`475`	`}`
`442`	`476`
`443`	`477`	`// Clean up command script`
`444`	`478`	`var cmdPath = GetGameExecutablePath(".cmd");`
`445`	`479`	`if (File.Exists(cmdPath))`
`446`	`480`	`{`
	`481`	`+ PassportLogger.Info($"[WindowsDeepLink] Deleting command script: {cmdPath}");`
`447`	`482`	`try`
`448`	`483`	`{`
`449`	`484`	`File.Delete(cmdPath);`
	`485`	`+ PassportLogger.Info($"[WindowsDeepLink] Command script deleted successfully");`
`450`	`486`	`}`
`451`	`487`	`catch (Exception ex)`
`452`	`488`	`{`
`453`		`- PassportLogger.Warn($"Failed to delete script: {ex.Message}");`
	`489`	`+ PassportLogger.Warn($"[WindowsDeepLink] Failed to delete script: {ex.Message}");`
`454`	`490`	`}`
`455`	`491`	`}`
`456`	`492`
`457`	`493`	`// Clean up instance`
	`494`	`+ PassportLogger.Info($"[WindowsDeepLink] Destroying WindowsDeepLink GameObject and clearing instance");`
`458`	`495`	`Destroy(gameObject);`
`459`	`496`	`_instance = null;`
`460`	`497`	`}`
Original file line number	Diff line number	Diff line change
`@@ -251,30 +251,51 @@ public async void OnDeepLinkActivated(string url)`
`251`	`251`	`{`
`252`	`252`	`try`
`253`	`253`	`{`
	`254`	`+ PassportLogger.Info($"{TAG} ===== DEEPLINK RECEIVED =====");`
`254`	`255`	`PassportLogger.Info($"{TAG} Received deeplink URL: {url}");`
	`256`	`+ PassportLogger.Info($"{TAG} _redirectUri={_redirectUri}, _logoutRedirectUri={_logoutRedirectUri}");`
`255`	`257`
`256`	`258`	`Uri uri = new Uri(url);`
`257`	`259`	`string hostWithPort = uri.IsDefaultPort ? uri.Host : $"{uri.Host}:{uri.Port}";`
`258`	`260`
`259`	`261`	`string domain = $"{uri.Scheme}://{hostWithPort}{uri.AbsolutePath}";`
	`262`	`+`
	`263`	`+ PassportLogger.Info($"{TAG} Parsed domain from deeplink: {domain}");`
`260`	`264`
`261`	`265`	`if (domain.EndsWith("/"))`
`262`	`266`	`{`
`263`	`267`	`domain = domain.Remove(domain.Length - 1);`
	`268`	`+ PassportLogger.Info($"{TAG} Removed trailing slash from domain: {domain}");`
`264`	`269`	`}`
`265`	`270`
	`271`	`+ PassportLogger.Info($"{TAG} Comparing domain '{domain}' with:");`
	`272`	`+ PassportLogger.Info($"{TAG} - _logoutRedirectUri: '{_logoutRedirectUri}'");`
	`273`	`+ PassportLogger.Info($"{TAG} - _redirectUri: '{_redirectUri}'");`
	`274`	`+`
`266`	`275`	`if (domain.Equals(_logoutRedirectUri))`
`267`	`276`	`{`
	`277`	`+ PassportLogger.Info($"{TAG} ✓ LOGOUT deeplink match! Calling HandleLogoutPkceSuccess...");`
`268`	`278`	`HandleLogoutPkceSuccess();`
`269`	`279`	`}`
`270`	`280`	`else if (domain.Equals(_redirectUri))`
`271`	`281`	`{`
	`282`	`+ PassportLogger.Info($"{TAG} ✓ LOGIN deeplink match! Calling CompleteLoginPKCEFlow...");`
`272`	`283`	`await CompleteLoginPKCEFlow(url);`
`273`	`284`	`}`
	`285`	`+ else`
	`286`	`+ {`
	`287`	`+ PassportLogger.Warn($"{TAG} ✗ Deeplink does NOT match logout or login URI!");`
	`288`	`+ PassportLogger.Warn($"{TAG} Received: '{domain}'");`
	`289`	`+ PassportLogger.Warn($"{TAG} Expected logout: '{_logoutRedirectUri}' OR login: '{_redirectUri}'");`
	`290`	`+ }`
	`291`	`+`
	`292`	`+ PassportLogger.Info($"{TAG} ===== DEEPLINK PROCESSING COMPLETED =====");`
`274`	`293`	`}`
`275`	`294`	`catch (Exception ex)`
`276`	`295`	`{`
`277`		`- PassportLogger.Error($"{TAG} Deeplink error {url}: {ex.Message}");`
	`296`	`+ PassportLogger.Error($"{TAG} ===== DEEPLINK ERROR =====");`
	`297`	`+ PassportLogger.Error($"{TAG} Deeplink error for URL {url}: {ex.Message}");`
	`298`	`+ PassportLogger.Error($"{TAG} Stack trace: {ex.StackTrace}");`
`278`	`299`	`}`
`279`	`300`	`}`
`280`	`301`
`@@ -454,20 +475,30 @@ public async UniTask<bool> Logout(bool hardLogout = true)`
`454`	`475`	`{`
`455`	`476`	`try`
`456`	`477`	`{`
	`478`	`+ PassportLogger.Info($"{TAG} ===== LOGOUT FLOW START =====");`
	`479`	`+ PassportLogger.Info($"{TAG} hardLogout={hardLogout}, _logoutRedirectUri={_logoutRedirectUri}");`
	`480`	`+`
`457`	`481`	`SendAuthEvent(PassportAuthEvent.LoggingOutPKCE);`
`458`	`482`
`459`	`483`	`var task = new UniTaskCompletionSource<bool>();`
`460`	`484`	`_pkceCompletionSource = task;`
	`485`	`+`
	`486`	`+ PassportLogger.Info($"{TAG} Created _pkceCompletionSource for logout");`
	`487`	`+`
`461`	`488`	`#if UNITY_STANDALONE_WIN \|\| (UNITY_ANDROID && UNITY_EDITOR_WIN) \|\| (UNITY_IPHONE && UNITY_EDITOR_WIN)`
	`489`	`+ PassportLogger.Info($"{TAG} Initialising WindowsDeepLink for logout with URI: {_logoutRedirectUri}");`
`462`	`490`	`WindowsDeepLink.Initialise(_logoutRedirectUri, OnDeepLinkActivated);`
	`491`	`+ PassportLogger.Info($"{TAG} WindowsDeepLink.Initialise completed");`
`463`	`492`	`#endif`
`464`	`493`	`LaunchLogoutPkceUrl(hardLogout);`
	`494`	`+ PassportLogger.Info($"{TAG} Waiting for logout callback (deep-link or completion)...");`
`465`	`495`	`return await task.Task;`
`466`	`496`	`}`
`467`	`497`	`catch (Exception ex)`
`468`	`498`	`{`
`469`	`499`	`var errorMessage = $"Failed to log out: {ex.Message}";`
`470`	`500`	`PassportLogger.Error($"{TAG} {errorMessage}");`
	`501`	`+ PassportLogger.Error($"{TAG} Stack trace: {ex.StackTrace}");`
`471`	`502`
`472`	`503`	`Track(PassportAnalytics.EventName.COMPLETE_LOGOUT_PKCE, success: false);`
`473`	`504`	`SendAuthEvent(PassportAuthEvent.LogoutPKCEFailed);`
`@@ -477,30 +508,53 @@ public async UniTask<bool> Logout(bool hardLogout = true)`
`477`	`508`
`478`	`509`	`private async void HandleLogoutPkceSuccess()`
`479`	`510`	`{`
	`511`	`+ PassportLogger.Info($"{TAG} ===== HANDLE LOGOUT SUCCESS CALLED =====");`
	`512`	`+ PassportLogger.Info($"{TAG} _isLoggedIn={_isLoggedIn}, _pkceCompletionSource={(_pkceCompletionSource == null ? "NULL" : "EXISTS")}");`
	`513`	`+`
`480`	`514`	`await UniTask.SwitchToMainThread();`
	`515`	`+`
	`516`	`+ PassportLogger.Info($"{TAG} Switched to main thread");`
	`517`	`+`
`481`	`518`	`if (_isLoggedIn)`
`482`	`519`	`{`
	`520`	`+ PassportLogger.Info($"{TAG} User was logged in, setting PKCE result to true");`
`483`	`521`	`TrySetPkceResult(true);`
`484`	`522`	`}`
	`523`	`+ else`
	`524`	`+ {`
	`525`	`+ PassportLogger.Warn($"{TAG} User was NOT logged in when HandleLogoutPkceSuccess was called!");`
	`526`	`+ }`
	`527`	`+`
`485`	`528`	`Track(PassportAnalytics.EventName.COMPLETE_LOGOUT_PKCE, success: true);`
`486`	`529`	`SendAuthEvent(PassportAuthEvent.LogoutPKCESuccess);`
	`530`	`+`
`487`	`531`	`_isLoggedIn = false;`
`488`	`532`	`_pkceCompletionSource = null;`
	`533`	`+`
	`534`	`+ PassportLogger.Info($"{TAG} ===== LOGOUT SUCCESS COMPLETED =====");`
`489`	`535`	`}`
`490`	`536`
`491`	`537`	`private async void LaunchLogoutPkceUrl(bool hardLogout)`
`492`	`538`	`{`
	`539`	`+ PassportLogger.Info($"{TAG} LaunchLogoutPkceUrl called with hardLogout={hardLogout}");`
	`540`	`+`
`493`	`541`	`var logoutUrl = await GetLogoutUrl();`
	`542`	`+`
	`543`	`+ PassportLogger.Info($"{TAG} Got logout URL: {logoutUrl}");`
	`544`	`+`
`494`	`545`	`if (hardLogout)`
`495`	`546`	`{`
	`547`	`+ PassportLogger.Info($"{TAG} Performing hard logout - launching browser...");`
`496`	`548`	`#if UNITY_ANDROID && !UNITY_EDITOR`
`497`	`549`	`LaunchAndroidUrl(logoutUrl);`
`498`	`550`	`#else`
`499`	`551`	`_communicationsManager.LaunchAuthURL(logoutUrl, _logoutRedirectUri);`
`500`	`552`	`#endif`
	`553`	`+ PassportLogger.Info($"{TAG} Browser launched with logout URL. Waiting for deep-link callback...");`
`501`	`554`	`}`
`502`	`555`	`else`
`503`	`556`	`{`
	`557`	`+ PassportLogger.Info($"{TAG} Performing soft logout (no browser) - calling HandleLogoutPkceSuccess directly");`
`504`	`558`	`HandleLogoutPkceSuccess();`
`505`	`559`	`}`
`506`	`560`	`}`
Original file line number	Diff line number	Diff line change
`@@ -628,12 +628,18 @@ private PassportImpl GetPassportImpl()`
`628`	`628`
`629`	`629`	`private void OnDeepLinkActivated(string url)`
`630`	`630`	`{`
	`631`	`+ PassportLogger.Info($"{TAG} [Passport.OnDeepLinkActivated] Deeplink received: {url}");`
`631`	`632`	`_deeplink = url;`
`632`	`633`
`633`	`634`	`if (_passportImpl != null)`
`634`	`635`	`{`
	`636`	`+ PassportLogger.Info($"{TAG} [Passport.OnDeepLinkActivated] Forwarding to PassportImpl...");`
`635`	`637`	`GetPassportImpl().OnDeepLinkActivated(url);`
`636`	`638`	`}`
	`639`	`+ else`
	`640`	`+ {`
	`641`	`+ PassportLogger.Warn($"{TAG} [Passport.OnDeepLinkActivated] _passportImpl is NULL - cannot forward deeplink!");`
	`642`	`+ }`
`637`	`643`	`}`
`638`	`644`
`639`	`645`	`private void OnPassportAuthEvent(PassportAuthEvent authEvent)`
Original file line number	Diff line number	Diff line change
`@@ -22,14 +22,26 @@ private async UniTaskVoid LogoutAsync()`
`22`	`22`	`}`
`23`	`23`	`try`
`24`	`24`	`{`
	`25`	`+ Debug.Log($"[LogoutScript] ===== LOGOUT BUTTON CLICKED =====");`
	`26`	`+ Debug.Log($"[LogoutScript] Starting logout process...");`
	`27`	`+`
`25`	`28`	`await Passport.Instance.Logout();`
	`29`	`+`
	`30`	`+ Debug.Log($"[LogoutScript] Logout completed successfully");`
	`31`	`+ Debug.Log($"[LogoutScript] Setting connection flags to false...");`
	`32`	`+`
`26`	`33`	`SampleAppManager.IsConnectedToImx = false;`
`27`	`34`	`SampleAppManager.IsConnectedToZkEvm = false;`
	`35`	`+`
	`36`	`+ Debug.Log($"[LogoutScript] Navigating to UnauthenticatedScene...");`
`28`	`37`	`AuthenticatedSceneManager.NavigateToUnauthenticatedScene();`
	`38`	`+ Debug.Log($"[LogoutScript] ===== LOGOUT FLOW COMPLETED =====");`
`29`	`39`	`}`
`30`	`40`	`catch (System.Exception ex)`
`31`	`41`	`{`
`32`		`- Debug.LogError($"Failed to logout: {ex.Message}");`
	`42`	`+ Debug.LogError($"[LogoutScript] ===== LOGOUT FAILED =====");`
	`43`	`+ Debug.LogError($"[LogoutScript] Failed to logout: {ex.Message}");`
	`44`	`+ Debug.LogError($"[LogoutScript] Stack trace: {ex.StackTrace}");`
`33`	`45`	`}`
`34`	`46`	`}`
`35`	`47`	`}`