fix: bugsweep aug16

Explorer/Assets/DCL/AuthenticationScreenFlow/AuthenticationScreenController.cs

@@ -82,16 +82,17 @@ public enum AuthStatus
         // misclassifying returning users whose cached identity expired.
         public bool IsCurrentlyNewAccount { get; internal set; }
 
-        public event Action DiscordButtonClicked;
-        public event Action<string, bool> OTPVerified;
-        public event Action OTPResend;
-        public event Action ProfileFinalized;
+        public event Action? DiscordButtonClicked;
+        public event Action<string, bool>? OTPVerified;
+        public event Action? OTPResend;
+        public event Action? ProfileFinalized;
 
         internal void RaiseProfileFinalized() =>
             ProfileFinalized?.Invoke();
 
-        private MVCStateMachine<AuthStateBase> fsm;
-        private AuthenticationScreenAudio audio;
+        // Null until OnViewInstantiated: the view is created lazily on first Show and may never be instantiated.
+        private MVCStateMachine<AuthStateBase>? fsm;
+        private AuthenticationScreenAudio? audio;
 
         public AuthenticationScreenController(
             ViewFactoryMethod viewFactory,
@@ -141,8 +142,8 @@ public override void Dispose()
             characterPreviewController?.Dispose();
 
             CancelLoginProcess();
-            audio.Dispose();
-            fsm.Dispose();
+            audio?.Dispose();
+            fsm?.Dispose();
         }
 
         protected override void OnViewInstantiated()
@@ -194,6 +195,7 @@ protected override void OnViewInstantiated()
         protected override void OnBeforeViewShow()
         {
             base.OnBeforeViewShow();
+
             // Force to re-login if the identity will expire in 24hs or less, so we mitigate the chances on
             // getting the identity expired while in-world, provoking signed-fetch requests to fail
             IWeb3Identity? storedIdentity = storedIdentityProvider.Identity;
@@ -206,7 +208,7 @@ protected override void OnBeforeViewShow()
             }
             else
             {
-                fsm.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
+                fsm!.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
             }
         }
 
@@ -217,10 +219,10 @@ private async UniTaskVoid TryAutoLoginAndProceedAsync(IWeb3Identity storedIdenti
                 bool autoLoginSuccess = await web3Authenticator.TryAutoLoginAsync(ct);
 
                 if (autoLoginSuccess)
-                    fsm.Enter<ProfileFetchingAuthState, ProfileFetchingPayload>(new (storedIdentity, storedIdentity.Source != IWeb3Identity.Web3IdentitySource.TokenFile, ct));
+                    fsm!.Enter<ProfileFetchingAuthState, ProfileFetchingPayload>(new (storedIdentity, storedIdentity.Source != IWeb3Identity.Web3IdentitySource.TokenFile, ct));
                 else
                 {
-                    fsm.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
+                    fsm!.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
                 }
             }
             catch (OperationCanceledException)
@@ -229,7 +231,7 @@ private async UniTaskVoid TryAutoLoginAndProceedAsync(IWeb3Identity storedIdenti
             catch (Exception e)
             {
                 ReportHub.LogException(e, new ReportData(ReportCategory.AUTHENTICATION));
-                fsm.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
+                fsm!.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.IN, true);
             }
         }
 
@@ -238,18 +240,18 @@ protected override void OnViewShow()
             base.OnViewShow();
 
             BlockUnwantedInputs();
-            audio.OnShow();
+            audio!.OnShow();
         }
 
         protected override void OnViewClose()
         {
             base.OnViewClose();
 
-            fsm.CurrentState?.Exit();
+            fsm!.CurrentState?.Exit();
             CancelLoginProcess();
 
             UnblockUnwantedInputs();
-            audio.OnHide();
+            audio!.OnHide();
         }
 
         protected override async UniTask WaitForCloseIntentAsync(CancellationToken ct)
@@ -288,7 +290,7 @@ async UniTaskVoid ChangeAccountAsync(CancellationToken ct)
 
                 await web3Authenticator.LogoutAsync(ct);
 
-                fsm.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.SLIDE, true);
+                fsm!.Enter<LoginSelectionAuthState, int>(UIAnimationHashes.SLIDE, true);
             }
         }
 

Explorer/Assets/DCL/AuthenticationScreenFlow/States/ProfileFetchingAuthState.cs

@@ -19,6 +19,7 @@ namespace DCL.AuthenticationScreenFlow
 {
     public class ProfileFetchingAuthState : AuthStateBase, IPayloadedState<ProfileFetchingPayload>
     {
+        private const int PROFILE_FETCH_ATTEMPTS = 3;
         private static readonly TimeSpan PROFILE_FETCH_TIMEOUT = TimeSpan.FromSeconds(15);
 
         private readonly MVCStateMachine<AuthStateBase> machine;
@@ -70,7 +71,7 @@ public override void Exit()
                                     ProfileNotFoundException ex => new SpanErrorInfo($"Profile not found during {nameof(ProfileFetchingAuthState)}", ex),
                                     NotAllowedUserException ex => new SpanErrorInfo(ex.Message, ex),
                                     TimeoutException ex => new SpanErrorInfo($"Profile fetch timed out during {nameof(ProfileFetchingAuthState)}", ex),
-                                    Exception ex => new SpanErrorInfo($"Unexpected error during {nameof(ProfileFetchingAuthState)}", ex),
+                                    { } ex => new SpanErrorInfo($"Unexpected error during {nameof(ProfileFetchingAuthState)}", ex),
                                 };
 
                 if (profileFetchException is not OperationCanceledException and not ProfileNotFoundException and not NotAllowedUserException)
@@ -110,9 +111,7 @@ private async UniTaskVoid FetchProfileFlowAsync(string email, IWeb3Identity iden
                     });
 
                     // Timeout surfaces catalyst stalls as CONNECTION_ERROR instead of a frozen spinner.
-                    Profile? profile = await selfProfile.ProfileAsync(ct).Timeout(PROFILE_FETCH_TIMEOUT);
-
-                    if (profile != null)
+                    if (await FetchProfileWithTimeoutRetriesAsync(selfProfile, PROFILE_FETCH_TIMEOUT, PROFILE_FETCH_ATTEMPTS, ct) is { } profile)
                     {
                         // When the profile was already in cache, for example your previous account after logout, we need to ensure that all systems related to the profile will update
                         profile.IsDirty = true;
@@ -156,6 +155,34 @@ private async UniTaskVoid FetchProfileFlowAsync(string email, IWeb3Identity iden
             }
         }
 
+        /// <summary>
+        ///     Each attempt owns a linked token, so a timed-out attempt cancels its underlying request instead of
+        ///     abandoning it. Only exhausting all attempts surfaces as <see cref="TimeoutException" /> (CONNECTION_ERROR);
+        ///     cancellation of <paramref name="ct" /> surfaces as <see cref="OperationCanceledException" />.
+        /// </summary>
+        internal static async UniTask<Profile?> FetchProfileWithTimeoutRetriesAsync(ISelfProfile selfProfile, TimeSpan attemptTimeout, int maxAttempts, CancellationToken ct)
+        {
+            for (var attempt = 1;; attempt++)
+            {
+                using CancellationTokenSource timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+                using IDisposable timeoutTimer = timeoutCts.CancelAfterSlim(attemptTimeout);
+
+                if (await selfProfile.ProfileAsync(timeoutCts.Token) is { } profile)
+                    return profile;
+
+                // The repository suppresses cancellation into a null profile, including cancellation of the flow token.
+                // Surface external cancellation as OCE so it is classified as a user cancel, not as "no deployed profile"
+                // (which on the cached flow would clear a still-valid stored identity)
+                ct.ThrowIfCancellationRequested();
+
+                if (!timeoutCts.IsCancellationRequested)
+                    return null; // genuine "no deployed profile"
+
+                if (attempt >= maxAttempts)
+                    throw new TimeoutException($"Profile fetch timed out after {maxAttempts} attempts of {attemptTimeout.TotalSeconds:F0}s each");
+            }
+        }
+
         private Profile CreateRandomProfile(string identityAddress)
         {
             var profile = Profile.NewRandomProfile(identityAddress);

Explorer/Assets/DCL/AuthenticationScreenFlow/Tests/AuthenticationScreenControllerShould.cs

@@ -0,0 +1,38 @@
+using NUnit.Framework;
+
+namespace DCL.AuthenticationScreenFlow.Tests
+{
+    [TestFixture]
+    public class AuthenticationScreenControllerShould
+    {
+        [Test]
+        public void NotThrowOnDisposeWhenViewWasNeverShown()
+        {
+            // Registered-but-never-shown lifecycle: the view factory is never invoked, so
+            // OnViewInstantiated never runs and the lazily-created members stay null
+            // (sessions with --skip-auth-screen + a valid cached identity).
+            // The constructor only stores its dependencies; none are dereferenced before the view exists.
+            var controller = new AuthenticationScreenController(
+                () => null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                string.Empty,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!,
+                null!);
+
+            Assert.DoesNotThrow(controller.Dispose);
+        }
+    }
+}