fix: auto-cancel credits top-up spinner when user returns from browser without paying

When the Stripe checkout tab was closed without completing a purchase, the Explorer
modal remained stuck on the "Continue the purchase in your browser..." spinner until
the foreground poll timed out (60 s) or the user manually pressed X.

Fix: subscribe to application focus events while the modal is in WaitingForBrowser
state. When the Explorer regains focus (the user returned from the browser), a
10-second grace period begins. If the poll receives a credited/failed status during
the grace period the normal success/failure flow continues; otherwise the top-up is
auto-cancelled and the modal resets to pack selection.

- Add IApplicationFocusSource interface and UnityApplicationFocusSource wrapper for
  Unity's Application.focusChanged — keeps CreditsTopUpModalController testable.
- Inject IApplicationFocusSource into CreditsTopUpModalController; subscribe on
  OnViewShow, unsubscribe on OnViewClose.
- WaitAndAutoCancelAsync: waits the grace period then calls CancelTopUp() if still
  in WaitingForBrowser state, also fires the BuyCreditsCancelled analytics event.
- Wire UnityApplicationFocusSource in CreditPurchasePlugin.
- New tests: CancelTopUpAfterGracePeriodWhenFocusReturnedWhileWaitingForBrowser,
  NotCancelTopUpWhenPaymentArrivesWithinGracePeriod.

Closes #9737

Author: decentraland-bot

Explorer/Assets/DCL/MarketplaceCredits/Purchase/Tests/CreditsTopUpModalControllerShould.cs

@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace DCL.MarketplaceCredits.Purchase.Tests
 {
@@ -17,6 +18,7 @@ public class CreditsTopUpModalControllerShould
         private static readonly CreditPack PACK = new ("pack_25", 24.99f, 235, true, string.Empty);
 
         private ICreditsTopUpService topUpService = null!;
+        private IApplicationFocusSource applicationFocusSource = null!;
         private TestableController controller = null!;
 
         private readonly List<(string orderId, CreditPack pack)> redirected = new ();
@@ -39,11 +41,13 @@ public void SetUp()
             packsLoadFailed.Clear();
 
             topUpService = Substitute.For<ICreditsTopUpService>();
+            applicationFocusSource = Substitute.For<IApplicationFocusSource>();
 
             controller = new TestableController(
                 topUpService,
                 Substitute.For<MarketplaceCreditsAPIClient>(null, null),
-                Substitute.For<IWeb3IdentityCache>());
+                Substitute.For<IWeb3IdentityCache>(),
+                applicationFocusSource);
 
             controller.RedirectedToStripe += (orderId, pack) => redirected.Add((orderId, pack));
             controller.BuyCreditsCompleted += (orderId, pack) => completed.Add((orderId, pack));
@@ -189,6 +193,69 @@ public void StartFromPackSelectionWhenReopenedAfterCancellingClose()
             Assert.AreEqual(1, cancelled.Count);
         }
 
+        [Test]
+        public async Task CancelTopUpAfterGracePeriodWhenFocusReturnedWhileWaitingForBrowser()
+        {
+            // Arrange: start with the service in WaitingForPayment so the controller
+            // enters WaitingForBrowser UI state; use a near-zero grace period.
+            topUpService.CurrentStatus.Returns(CreditsTopUpStatus.WaitingForPayment(PACK, ORDER_ID));
+            var fastController = new TestableController(
+                topUpService,
+                Substitute.For<MarketplaceCreditsAPIClient>(null, null),
+                Substitute.For<IWeb3IdentityCache>(),
+                applicationFocusSource,
+                gracePeriod: TimeSpan.FromMilliseconds(30));
+
+            fastController.BuyCreditsCancelled += (orderId, pack) => cancelled.Add((orderId, pack));
+
+            fastController.Show();
+            RaiseStatus(CreditsTopUpStatus.WaitingForPayment(PACK, ORDER_ID));
+
+            // Act: simulate the user returning focus to the Explorer (browser tab closed).
+            applicationFocusSource.FocusChanged += Raise.Event<Action<bool>>(true);
+
+            // Assert: after the grace period the service must have been cancelled.
+            await Task.Delay(200);
+            topUpService.Received(1).CancelTopUp();
+            Assert.AreEqual(1, cancelled.Count);
+            Assert.AreEqual(ORDER_ID, cancelled[0].orderId);
+
+            fastController.Dispose();
+        }
+
+        [Test]
+        public async Task NotCancelTopUpWhenPaymentArrivesWithinGracePeriod()
+        {
+            // Arrange: service in WaitingForPayment; grace period shorter than payment arrival simulation.
+            topUpService.CurrentStatus.Returns(CreditsTopUpStatus.WaitingForPayment(PACK, ORDER_ID));
+            var fastController = new TestableController(
+                topUpService,
+                Substitute.For<MarketplaceCreditsAPIClient>(null, null),
+                Substitute.For<IWeb3IdentityCache>(),
+                applicationFocusSource,
+                gracePeriod: TimeSpan.FromMilliseconds(100));
+
+            fastController.BuyCreditsCompleted += (orderId, pack) => completed.Add((orderId, pack));
+
+            fastController.Show();
+            RaiseStatus(CreditsTopUpStatus.WaitingForPayment(PACK, ORDER_ID));
+
+            // Act: user returns focus, but payment arrives before grace period expires.
+            applicationFocusSource.FocusChanged += Raise.Event<Action<bool>>(true);
+
+            // Simulate payment arriving within the grace period (immediately after focus).
+            topUpService.CurrentStatus.Returns(CreditsTopUpStatus.Credited(PACK, ORDER_ID, 250, 300));
+            RaiseStatus(CreditsTopUpStatus.Credited(PACK, ORDER_ID, 250, 300));
+
+            await Task.Delay(300);
+
+            // Assert: CancelTopUp must NOT have been called — success won the race.
+            topUpService.DidNotReceive().CancelTopUp();
+            Assert.AreEqual(1, completed.Count);
+
+            fastController.Dispose();
+        }
+
         private void RaiseStatus(CreditsTopUpStatus status) =>
             topUpService.StatusChanged += Raise.Event<Action<CreditsTopUpStatus>>(status);
 
@@ -198,8 +265,17 @@ private class TestableController : CreditsTopUpModalController
             public TestableController(
                 ICreditsTopUpService topUpService,
                 MarketplaceCreditsAPIClient creditsApiClient,
-                IWeb3IdentityCache identityCache)
-                : base(() => null!, topUpService, creditsApiClient, identityCache, null!) { }
+                IWeb3IdentityCache identityCache,
+                IApplicationFocusSource? applicationFocusSource = null,
+                TimeSpan? gracePeriod = null)
+                : base(
+                    () => null!,
+                    topUpService,
+                    creditsApiClient,
+                    identityCache,
+                    null!,
+                    applicationFocusSource ?? Substitute.For<IApplicationFocusSource>(),
+                    gracePeriod) { }
 
             public void Show() =>
                 OnViewShow();

Explorer/Assets/DCL/MarketplaceCredits/Purchase/TopUp/IApplicationFocusSource.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace DCL.MarketplaceCredits.Purchase.TopUp
+{
+    /// <summary>
+    /// Abstracts Unity's <c>Application.focusChanged</c> for testability.
+    /// </summary>
+    public interface IApplicationFocusSource
+    {
+        /// <summary>
+        /// Raised when the application gains or loses OS focus.
+        /// <c>true</c> = focus gained, <c>false</c> = focus lost.
+        /// </summary>
+        event Action<bool> FocusChanged;
+    }
+}

Explorer/Assets/DCL/MarketplaceCredits/Purchase/TopUp/UI/CreditsTopUpModalController.cs

@@ -29,10 +29,14 @@ private enum ModalState
         private const string PACKS_LOAD_FAILED_REQUEST = "request_failed";
         private const string PACKS_LOAD_FAILED_EMPTY = "empty_response";
 
+        private static readonly TimeSpan DEFAULT_FOCUS_RETURN_GRACE_PERIOD = TimeSpan.FromSeconds(10);
+
         private readonly ICreditsTopUpService topUpService;
         private readonly MarketplaceCreditsAPIClient creditsApiClient;
         private readonly IWeb3IdentityCache identityCache;
         private readonly ImageControllerProvider imageControllerProvider;
+        private readonly IApplicationFocusSource applicationFocusSource;
+        private readonly TimeSpan focusReturnGracePeriod;
 
         private ModalState currentState;
         private CreditsTopUpStage lastStage = CreditsTopUpStage.Idle;
@@ -57,13 +61,17 @@ public CreditsTopUpModalController(
             ICreditsTopUpService topUpService,
             MarketplaceCreditsAPIClient creditsApiClient,
             IWeb3IdentityCache identityCache,
-            ImageControllerProvider imageControllerProvider)
+            ImageControllerProvider imageControllerProvider,
+            IApplicationFocusSource applicationFocusSource,
+            TimeSpan? focusReturnGracePeriod = null)
             : base(viewFactory)
         {
             this.topUpService = topUpService;
             this.creditsApiClient = creditsApiClient;
             this.identityCache = identityCache;
             this.imageControllerProvider = imageControllerProvider;
+            this.applicationFocusSource = applicationFocusSource;
+            this.focusReturnGracePeriod = focusReturnGracePeriod ?? DEFAULT_FOCUS_RETURN_GRACE_PERIOD;
             topUpService.StatusChanged += OnServiceStatusChanged;
         }
 
@@ -85,11 +93,13 @@ protected override void OnViewShow()
             LoadAndBindPacksAsync(lifeCts.Token).Forget();
             LoadBalanceAsync(lifeCts.Token).Forget();
 
+            applicationFocusSource.FocusChanged += OnApplicationFocusChanged;
             ModalOpened?.Invoke(inputData.Source);
         }
 
         protected override void OnViewClose()
         {
+            applicationFocusSource.FocusChanged -= OnApplicationFocusChanged;
             isViewShown = false;
             purchasedPackItem = null;
 
@@ -242,6 +252,31 @@ private void OnRetryClicked()
             topUpService.AcknowledgeTerminalState();
         }
 
+        private void OnApplicationFocusChanged(bool hasFocus)
+        {
+            if (!hasFocus || currentState != ModalState.WaitingForBrowser)
+                return;
+
+            // The user has returned to the Explorer while the Stripe checkout was open.
+            // Wait a short grace period to let a completed payment arrive via the poll cycle;
+            // if the state is still WaitingForBrowser after the grace period, the user
+            // likely cancelled in the browser — auto-cancel the top-up on their behalf.
+            WaitAndAutoCancelAsync(lifeCts!.Token).Forget();
+        }
+
+        private async UniTaskVoid WaitAndAutoCancelAsync(CancellationToken ct)
+        {
+            bool wasCancelled = await UniTask.Delay(focusReturnGracePeriod, cancellationToken: ct)
+                                             .SuppressCancellationThrow();
+
+            if (wasCancelled || currentState != ModalState.WaitingForBrowser)
+                return;
+
+            CreditsTopUpStatus status = topUpService.CurrentStatus;
+            BuyCreditsCancelled?.Invoke(status.OrderId!, status.Pack);
+            topUpService.CancelTopUp();
+        }
+
         private void OnServiceStatusChanged(CreditsTopUpStatus status)
         {
             if (status.Stage != lastStage)

Explorer/Assets/DCL/MarketplaceCredits/Purchase/TopUp/UnityApplicationFocusSource.cs

@@ -0,0 +1,27 @@
+using System;
+using UnityEngine;
+
+namespace DCL.MarketplaceCredits.Purchase.TopUp
+{
+    /// <summary>
+    /// Forwards Unity's <c>Application.focusChanged</c> event through <see cref="IApplicationFocusSource"/>.
+    /// Subscribe via the interface; dispose to unsubscribe from the Unity event.
+    /// </summary>
+    public class UnityApplicationFocusSource : IApplicationFocusSource, IDisposable
+    {
+        public event Action<bool>? FocusChanged;
+
+        public UnityApplicationFocusSource()
+        {
+            Application.focusChanged += OnFocusChanged;
+        }
+
+        public void Dispose()
+        {
+            Application.focusChanged -= OnFocusChanged;
+        }
+
+        private void OnFocusChanged(bool hasFocus) =>
+            FocusChanged?.Invoke(hasFocus);
+    }
+}

Explorer/Assets/DCL/PluginSystem/Global/CreditPurchasePlugin.cs

@@ -32,6 +32,7 @@ public class CreditPurchasePlugin : IDCLGlobalPlugin<CreditPurchasePlugin.Credit
         private CreditPurchaseModalController? creditPurchaseModalController;
         private ICreditsTopUpService? creditsTopUpService;
         private CreditsTopUpModalController? creditsTopUpModalController;
+        private UnityApplicationFocusSource? applicationFocusSource;
 
         public CreditPurchasePlugin(
             IAssetsProvisioner assetsProvisioner,
@@ -56,6 +57,7 @@ public void Dispose()
             creditPurchaseModalController?.Dispose();
             creditsTopUpModalController?.Dispose();
             creditsTopUpService?.Dispose();
+            applicationFocusSource?.Dispose();
         }
 
         public void InjectToWorld(ref ArchSystemsWorldBuilder<Arch.Core.World> builder, in GlobalPluginArguments arguments) { }
@@ -76,6 +78,7 @@ public async UniTask InitializeAsync(CreditPurchaseSettings settings, Cancellati
             mvcManager.RegisterController(creditPurchaseModalController);
 
             creditsTopUpService = new CreditsTopUpService(marketplaceCreditsAPIClient, web3IdentityCache, webBrowser);
+            applicationFocusSource = new UnityApplicationFocusSource();
 
             CreditsTopUpModalView topUpViewAsset = (await assetsProvisioner.ProvideMainAssetValueAsync(settings.CreditsTopUpPopupPrefab, ct: ct)).GetComponent<CreditsTopUpModalView>();
 
@@ -84,7 +87,8 @@ public async UniTask InitializeAsync(CreditPurchaseSettings settings, Cancellati
                 creditsTopUpService,
                 marketplaceCreditsAPIClient,
                 web3IdentityCache,
-                imageControllerProvider);
+                imageControllerProvider,
+                applicationFocusSource);
 
             mvcManager.RegisterController(creditsTopUpModalController);
         }