@jamesmontemagno I hope you can figure out what is happening this is my testing result. Logging was added with Claude, so I hope he really added it on each relevant part.

I made a fork of your project and added a bunch of logging here: https://github.com/Sebastian1989101/InAppBillingPlugin

This is my service class within my app:

using System.Text;
using CommunityToolkit.Mvvm.Messaging;
using Plugin.InAppBilling;
using TearsCompanion.Models.Messages;
using TearsCompanion.Models.Settings;
using TearsCompanion.Resources.Strings;

namespace TearsCompanion.Services;

public interface IInAppBillingVerifyPurchaseEx : IInAppBillingVerifyPurchase
{
    Task PurchaseDone(string identifier, bool unlock);
    Task<bool> RestoreCrossAppUnlocks(bool callFromRestore = false);
    void AddToUnlockVerifyData(IAppSettings settings, IEnumerable<InAppBillingPurchase>? purchases);
    Task<bool> VerifyPurchase(InAppBillingPurchase purchase);
    Task<bool> VerifyPurchase(string bundleId, string? signedData, string? signature, string productId, string? transactionId, bool skipNewValidationFlag = false);
}

public static class InAppBillingPlatformWrapper
{
    private static IInAppBilling? _implementation;

    public static IInAppBilling Implementation => _implementation ??= CrossInAppBilling.Current;

    public static void Init(IInAppBilling implementation)
    {
        _implementation = implementation;
    }
}

public interface IInAppPurchaseService
{
    Task<IEnumerable<PurchasableProduct>> GetAllAvailableProductsAsync();

    Task<bool> PurchaseAsync(string identifier);
    Task<bool> RestoreUnlockAsync(bool isSubscriptionPage = false);

    Task AcknowledgeConsumeOpenPurchases();

    Task<bool> MarkProductAsPurchased(string identifier, bool unlock = true, bool invokePurchaseDone = true);
}

public class InAppPurchaseService(ILogger<InAppPurchaseService> logger, IAppSettings settings, ICoreService coreService, IInAppBillingVerifyPurchaseEx verifyPurchase) : IInAppPurchaseService
{
    public async Task<IEnumerable<PurchasableProduct>> GetAllAvailableProductsAsync()
    {
        logger.LogInformation("GetAllAvailableProductsAsync: Started");
        if (!coreService.CanUseInAppPurchases())
        {
            logger.LogInformation("GetAllAvailableProductsAsync: InAppPurchases not available, returning empty");
            return Enumerable.Empty<PurchasableProduct>();
        }

#if DEBUG
        logger.LogInformation("GetAllAvailableProductsAsync: DEBUG mode, simulating delay");
        await Task.Delay(3000);
        return AppPurchaseConfig.InAppPurchaseAllProductIdentifiers.Select(p => new PurchasableProduct(p, "0.99$", "USD", 0, AppPurchaseConfig.InAppPurchaseTipProductIdentifiers.Contains(p), AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers.Contains(p), new Random().Next(0, 10) > 4 ? "0.49$" : null, new Random().Next(0, 10) > 4));
#else
        try
        {
            logger.LogInformation("GetAllAvailableProductsAsync: Attempting to connect to store");
            var connection = await InAppBillingPlatformWrapper.Implementation.ConnectAsync();
            logger.LogInformation($"GetAllAvailableProductsAsync: Connection result = {connection}");
            if (!connection)
                throw new ApplicationException(AppResources.InAppPurchase_ErrorConnectingStore);

            var purchases = new List<InAppBillingProduct>();

            var normalPurchases = AppPurchaseConfig.InAppPurchaseAllProductIdentifiers.Except(AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers).ToArray();
            var subscriptions = AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers;

            logger.LogInformation($"GetAllAvailableProductsAsync: Normal purchases count = {normalPurchases.Length}, Subscriptions count = {subscriptions.Length}");

            if (normalPurchases.Any())
            {
                logger.LogInformation("GetAllAvailableProductsAsync: Getting product info for InAppPurchase items");
                purchases.AddRange(await InAppBillingPlatformWrapper.Implementation.GetProductInfoAsync(ItemType.InAppPurchase, normalPurchases));
                logger.LogInformation($"GetAllAvailableProductsAsync: Retrieved {purchases.Count} InAppPurchase products");
            }

            if (subscriptions.Any())
            {
                logger.LogInformation("GetAllAvailableProductsAsync: Getting product info for Subscription items");
                purchases.AddRange(await InAppBillingPlatformWrapper.Implementation.GetProductInfoAsync(ItemType.Subscription, AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers));
                logger.LogInformation($"GetAllAvailableProductsAsync: Total products after subscriptions = {purchases.Count}");

            logger.LogInformation("GetAllAvailableProductsAsync: Mapping products to PurchasableProduct objects");
            var result = purchases.Select(p =>
            {
                string? reducedPrice = null;
                bool isFamilyShareable = false;

                if (DeviceInfo.Current.Platform == DevicePlatform.iOS && p.AppleExtras != null)
                {
                    if (p.AppleExtras.Discounts.FirstOrDefault(d => d.Type == ProductDiscountType.Subscription) is { } subDiscount)
                        reducedPrice = subDiscount.LocalizedPrice;
                    else if (p.AppleExtras.Discounts.FirstOrDefault(d => d.Type == ProductDiscountType.Introductory) is { } intDiscount)
                        reducedPrice = intDiscount.LocalizedPrice;
                    else if (p.AppleExtras.IntroductoryOffer != null)
                        reducedPrice = p.AppleExtras.IntroductoryOffer.LocalizedPrice;

                    isFamilyShareable = p.AppleExtras.IsFamilyShareable;
                }

                return new PurchasableProduct(p.ProductId, p.LocalizedPrice, p.CurrencyCode, p.MicrosPrice,
                    AppPurchaseConfig.InAppPurchaseTipProductIdentifiers.Contains(p.ProductId),
                    AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers.Contains(p.ProductId), 
                    reducedPrice, isFamilyShareable);
            });
            logger.LogInformation("GetAllAvailableProductsAsync: Completed successfully");
            return result;
        }
        catch (InAppBillingPurchaseException ex)
        {
            logger.LogError(ex, $"GetAllAvailableProductsAsync: InAppBillingPurchaseException - {ex.PurchaseError}: {ex.Message}");
            throw;
        }
        finally
        {
            logger.LogInformation("GetAllAvailableProductsAsync: Disconnecting from store");
            await InAppBillingPlatformWrapper.Implementation.DisconnectAsync();
            logger.LogInformation("GetAllAvailableProductsAsync: Disconnected");
        }
#endif
    }

    public async Task<bool> PurchaseAsync(string identifier)
    {
        logger.LogInformation($"PurchaseAsync: Started for product {identifier}");
        if (!coreService.CanUseInAppPurchases())
        {
            logger.LogInformation("PurchaseAsync: InAppPurchases not available, returning false");
            return false;
        }

        if (AppPurchaseConfig.InAppPurchaseTipProductIdentifiers.Contains(identifier))
        {
            logger.LogInformation($"PurchaseAsync: Product {identifier} is a consumable tip");
            return await PurchaseConsumableAsync(identifier);
        }

        logger.LogInformation($"PurchaseAsync: Product {identifier} is a default purchase");
        return await PurchaseDefaultAsync(identifier);
    }

    private async Task<bool> PurchaseDefaultAsync(string identifier)
    {
        logger.LogInformation($"PurchaseDefaultAsync: Started for product {identifier}");
        try
        {
#if DEBUG
            logger.LogInformation("PurchaseDefaultAsync: DEBUG mode, simulating purchase");
            var verifyData = settings.UnlockVerifyData;
            verifyData[identifier] = new Newtonsoft.Json.Linq.JObject(
                new Newtonsoft.Json.Linq.JProperty("bundleId", AppInfo.Current.PackageName),
                new Newtonsoft.Json.Linq.JProperty("signedData", "DEBUG SIGNED DATA"),
                new Newtonsoft.Json.Linq.JProperty("signature", "DEBUG SIGNATURE"),
                new Newtonsoft.Json.Linq.JProperty("productId", identifier),
                new Newtonsoft.Json.Linq.JProperty("transactionId", "00000001")).ToString();

            settings.UnlockVerifyData = verifyData;

            await MarkProductAsPurchased(identifier);
            logger.LogInformation("PurchaseDefaultAsync: DEBUG purchase completed");
            return true;
#else

            logger.LogInformation("PurchaseDefaultAsync: Attempting to connect to store");
            var connection = await InAppBillingPlatformWrapper.Implementation.ConnectAsync();
            logger.LogInformation($"PurchaseDefaultAsync: Connection result = {connection}");
            if (!connection)
                throw new ApplicationException(AppResources.InAppPurchase_ErrorConnectingStore);

            var itemType = AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers.Contains(identifier) ? ItemType.Subscription : ItemType.InAppPurchase;
            logger.LogInformation($"PurchaseDefaultAsync: ItemType = {itemType} for product {identifier}");

            logger.LogInformation($"PurchaseDefaultAsync: Calling PurchaseAsync for {identifier}");
            var purchase = await InAppBillingPlatformWrapper.Implementation.PurchaseAsync(identifier, itemType);
            logger.LogInformation($"PurchaseDefaultAsync: PurchaseAsync completed, purchase is {(purchase == null ? "null" : "not null")}");

            if (purchase != null)
            {
                logger.LogInformation($"PurchaseDefaultAsync: Verifying purchase for {identifier}");
                if (!await verifyPurchase.VerifyPurchase(purchase))
                {
                    logger.LogWarning($"PurchaseDefaultAsync: Purchase verification failed for {identifier}");
                    purchase = null;
                }
                else
                {
                    logger.LogInformation($"PurchaseDefaultAsync: Purchase verified successfully for {identifier}");
                }
            }

            if (purchase == null)
            {
                logger.LogInformation($"PurchaseDefaultAsync: Purchase is null, attempting to restore from existing purchases");
                var delayMs = new Random().Next(500, 2000);
                logger.LogInformation($"PurchaseDefaultAsync: Delaying {delayMs}ms before restore attempt");
                await Task.Delay(delayMs);

                logger.LogInformation($"PurchaseDefaultAsync: Calling GetPurchasesAsync({itemType}) to restore");
                var restoredPurchases = await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(itemType);
                logger.LogInformation($"PurchaseDefaultAsync: GetPurchasesAsync returned {restoredPurchases?.Count() ?? 0} purchases");

                purchase = restoredPurchases?.FirstOrDefault(p => p.ProductId == identifier);
                logger.LogInformation($"PurchaseDefaultAsync: Restored purchase for {identifier} is {(purchase == null ? "null" : "not null")}");

                if (purchase == null)
                {
                    logger.LogError($"PurchaseDefaultAsync: Could not find purchase for {identifier} after restore attempt");
                    throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchasingProduct);
                }
            }

            logger.LogInformation($"PurchaseDefaultAsync: Purchase state = {purchase.State}");
            if (purchase.State == PurchaseState.PaymentPending)
            {
                logger.LogWarning($"PurchaseDefaultAsync: Payment is pending for {identifier}");
                var openPurchases = settings.OpenPurchases;
                if (!openPurchases.Contains(identifier))
                {
                    openPurchases.Add(identifier);
                    logger.LogInformation($"PurchaseDefaultAsync: Added {identifier} to open purchases");
                }

                throw new ApplicationException(AppResources.InAppPurchase_ErrorPaymentPending);
            }

            if (DeviceInfo.Platform != DevicePlatform.iOS && DeviceInfo.Platform != DevicePlatform.MacCatalyst && DeviceInfo.Platform != DevicePlatform.macOS)
            {
                logger.LogInformation($"PurchaseDefaultAsync: Non-iOS platform, finalizing purchase for {identifier}");
                var acknowledged = await InAppBillingPlatformWrapper.Implementation.FinalizePurchaseAsync([purchase.PurchaseToken]);
                var success = acknowledged?.FirstOrDefault(r => r.Id == purchase.PurchaseToken).Success ?? false;
                logger.LogInformation($"PurchaseDefaultAsync: FinalizePurchaseAsync result = {success}");

                if (!success)
                {
                    logger.LogError($"PurchaseDefaultAsync: Failed to finalize purchase for {identifier}");
                    throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchasingProduct);
                }
            }

            if (purchase.State == PurchaseState.Purchased || purchase.State == PurchaseState.Restored)
            {
                logger.LogInformation($"PurchaseDefaultAsync: Marking product {identifier} as purchased");
                var success = await MarkProductAsPurchased(identifier);
                logger.LogInformation($"PurchaseDefaultAsync: MarkProductAsPurchased result = {success}");

                if (!success)
                {
                    logger.LogError($"PurchaseDefaultAsync: Failed to mark product {identifier} as purchased");
                    throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchaseActivation);
                }

                logger.LogInformation($"PurchaseDefaultAsync: Completed successfully for {identifier}");
                return success;
            }

            logger.LogError($"PurchaseDefaultAsync: Unexpected purchase state {purchase.State} for {identifier}");
            throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchasingProduct);
#endif
        }
        catch (InAppBillingPurchaseException ex)
        {
            logger.LogError(ex, $"PurchaseDefaultAsync: InAppBillingPurchaseException for {identifier} - {ex.PurchaseError}: {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, $"PurchaseDefaultAsync: Exception for {identifier} - {ex.Message}");
            throw;
        }
        finally
        {
            logger.LogInformation($"PurchaseDefaultAsync: Disconnecting from store for {identifier}");
            await InAppBillingPlatformWrapper.Implementation.DisconnectAsync();
            logger.LogInformation($"PurchaseDefaultAsync: Disconnected for {identifier}");
        }
    }

    private async Task<bool> PurchaseConsumableAsync(string identifier)
    {
        logger.LogInformation($"PurchaseConsumableAsync: Started for product {identifier}");
        try
        {
            logger.LogInformation("PurchaseConsumableAsync: Attempting to connect to store");
            var connection = await InAppBillingPlatformWrapper.Implementation.ConnectAsync();
            logger.LogInformation($"PurchaseConsumableAsync: Connection result = {connection}");
            if (!connection)
                throw new ApplicationException(AppResources.InAppPurchase_ErrorConnectingStore);

            logger.LogInformation($"PurchaseConsumableAsync: Calling PurchaseAsync for {identifier}");
            var purchase = await InAppBillingPlatformWrapper.Implementation.PurchaseAsync(identifier, ItemType.InAppPurchase);
            logger.LogInformation($"PurchaseConsumableAsync: PurchaseAsync completed, purchase is {(purchase == null ? "null" : "not null")}");

            if (purchase != null)
            {
                logger.LogInformation($"PurchaseConsumableAsync: Verifying purchase for {identifier}");
                if (!await verifyPurchase.VerifyPurchase(purchase))
                {
                    logger.LogWarning($"PurchaseConsumableAsync: Purchase verification failed for {identifier}");
                    purchase = null;
                }
                else
                {
                    logger.LogInformation($"PurchaseConsumableAsync: Purchase verified successfully for {identifier}");
                }
            }

            if (purchase == null)
            {
                logger.LogError($"PurchaseConsumableAsync: Purchase is null for {identifier}");
                throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchasingProduct);
            }

            logger.LogInformation($"PurchaseConsumableAsync: Purchase state = {purchase.State}");
            if (purchase.State == PurchaseState.PaymentPending)
            {
                logger.LogWarning($"PurchaseConsumableAsync: Payment is pending for {identifier}");
                var openPurchases = settings.OpenPurchases;
                if (!openPurchases.Contains(identifier))
                {
                    openPurchases.Add(identifier);
                    logger.LogInformation($"PurchaseConsumableAsync: Added {identifier} to open purchases");
                }

                throw new ApplicationException(AppResources.InAppPurchase_ErrorPaymentPending);
            }

            if (DeviceInfo.Platform != DevicePlatform.iOS && DeviceInfo.Platform != DevicePlatform.MacCatalyst && DeviceInfo.Platform != DevicePlatform.macOS)
            {
                logger.LogInformation($"PurchaseConsumableAsync: Non-iOS platform, consuming purchase for {identifier}");
                var consumedItem = await InAppBillingPlatformWrapper.Implementation.ConsumePurchaseAsync(purchase.ProductId, purchase.PurchaseToken);
                logger.LogInformation($"PurchaseConsumableAsync: ConsumePurchaseAsync result = {consumedItem}");

                if (!consumedItem)
                {
                    logger.LogError($"PurchaseConsumableAsync: Failed to consume purchase for {identifier}");
                    throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchaseActivation);
                }
            }

            if (purchase.State == PurchaseState.Purchased || purchase.State == PurchaseState.Restored)
            {
                logger.LogInformation($"PurchaseConsumableAsync: Marking product {identifier} as purchased");
                await MarkProductAsPurchased(identifier);
            }
            else
            {
                logger.LogError($"PurchaseConsumableAsync: Unexpected purchase state {purchase.State} for {identifier}");
                throw new ApplicationException(AppResources.InAppPurchase_ErrorPurchasingProduct);
            }

            logger.LogInformation($"PurchaseConsumableAsync: Completed successfully for {identifier}");
            return true;
        }
        catch (InAppBillingPurchaseException ex)
        {
            logger.LogError(ex, $"PurchaseConsumableAsync: InAppBillingPurchaseException for {identifier} - {ex.PurchaseError}: {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, $"PurchaseConsumableAsync: Exception for {identifier} - {ex.Message}");
            throw;
        }
        finally
        {
            logger.LogInformation($"PurchaseConsumableAsync: Disconnecting from store for {identifier}");
            await InAppBillingPlatformWrapper.Implementation.DisconnectAsync();
            logger.LogInformation($"PurchaseConsumableAsync: Disconnected for {identifier}");
        }
    }

    public async Task<bool> RestoreUnlockAsync(bool isSubscriptionPage = false)
    {
        logger.LogInformation($"RestoreUnlockAsync: Started (isSubscriptionPage = {isSubscriptionPage})");
        try
        {
            if (!coreService.CanUseInAppPurchases())
            {
                logger.LogInformation("RestoreUnlockAsync: InAppPurchases not available, returning false");
                return false;
            }

            logger.LogInformation("RestoreUnlockAsync: Attempting to connect to store");
            var connection = await InAppBillingPlatformWrapper.Implementation.ConnectAsync();
            logger.LogInformation($"RestoreUnlockAsync: Connection result = {connection}");
            if (!connection)
                throw new ApplicationException(AppResources.InAppPurchase_ErrorConnectingStore);

            logger.LogInformation("RestoreUnlockAsync: Calling GetPurchasesAsync(ItemType.InAppPurchase)");
            var purchases = (await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(ItemType.InAppPurchase))?.ToArray();
            logger.LogInformation($"RestoreUnlockAsync: GetPurchasesAsync(InAppPurchase) returned {purchases?.Length ?? 0} purchases");

            logger.LogInformation("RestoreUnlockAsync: Calling GetPurchasesAsync(ItemType.Subscription)");
            var subscriptionPurchases = await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(ItemType.Subscription); // SOFT LOCK HERE ON RESTORE
            logger.LogInformation($"RestoreUnlockAsync: GetPurchasesAsync(Subscription) returned {subscriptionPurchases?.Count() ?? 0} purchases");

            purchases = purchases != null ?
                purchases.Concat(subscriptionPurchases).ToArray() :
                subscriptionPurchases?.ToArray();

            logger.LogInformation($"RestoreUnlockAsync: Total purchases (before filtering) = {purchases?.Length ?? 0}");

            if (purchases != null)
            {
                logger.LogInformation("RestoreUnlockAsync: Filtering and grouping purchases");
                var filteredPurchases = purchases.Where(p => p.State == PurchaseState.Purchased || p.State == PurchaseState.Purchasing || p.State == PurchaseState.Restored || p.State == PurchaseState.Unknown);
                logger.LogInformation($"RestoreUnlockAsync: Purchases after state filter = {filteredPurchases.Count()}");

                purchases = filteredPurchases
                    .OrderByDescending(p => p.TransactionDateUtc)
                    .GroupBy(p => AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers.Contains(p.ProductId) ? ItemType.Subscription.ToString() : p.ProductId)
                    .Select(g => g.First())
                    .ToArray();

                logger.LogInformation($"RestoreUnlockAsync: Purchases after grouping = {purchases.Length}");
            }

            logger.LogInformation("RestoreUnlockAsync: Adding purchases to unlock verify data");
            verifyPurchase.AddToUnlockVerifyData(settings, purchases);

            var status = false;
            try
            {
                logger.LogInformation("RestoreUnlockAsync: Attempting to restore cross-app unlocks");
                if (await verifyPurchase.RestoreCrossAppUnlocks(true))
                {
                    logger.LogInformation("RestoreUnlockAsync: Cross-app unlocks restored successfully");
                    status = true;
                    if ((purchases == null || !purchases.Any()))
                    {
                        logger.LogInformation("RestoreUnlockAsync: No purchases found but cross-app restore succeeded, returning true");
                        return true;
                    }
                }
                else
                {
                    logger.LogInformation("RestoreUnlockAsync: Cross-app unlocks restore returned false");
                }
            }
            catch (Exception ex)
            {
                logger.LogWarning(ex, "RestoreUnlockAsync: Exception during cross-app unlock restore (ignored)");
            }

            if (purchases == null || !purchases.Any())
            {
                logger.LogWarning("RestoreUnlockAsync: No purchases to restore");
                var builder = new StringBuilder();
                builder.AppendLine(AppResources.InAppPurchase_ErrorRestoringProducts);

                if (isSubscriptionPage)
                {
                    builder.AppendLine(Environment.NewLine);
                    builder.AppendLine(AppResources.InAppPurchase_ErrorSubscriptionRestore);
                }

                throw new ApplicationException(builder.ToString());
            }

            var openPurchases = settings.OpenPurchases;
            logger.LogInformation($"RestoreUnlockAsync: Open purchases count = {openPurchases.Count}");
            if (openPurchases.Any())
            {
                logger.LogInformation("RestoreUnlockAsync: Attempting to acknowledge/consume open purchases");
                if (await AcknowledgeConsumeOpenPurchases(purchases, openPurchases))
                {
                    logger.LogInformation("RestoreUnlockAsync: Open purchases acknowledged/consumed successfully");
                    status = true;
                }
            }

            logger.LogInformation("RestoreUnlockAsync: Processing purchased/restored items");
            var purchasedCount = 0;
            foreach (var purchase in purchases.Where(p => p.State == PurchaseState.Purchased || p.State == PurchaseState.Restored))
            {
                logger.LogInformation($"RestoreUnlockAsync: Processing purchase {purchase.ProductId} with state {purchase.State}");
                if (await MarkProductAsPurchased(purchase.ProductId))
                {
                    purchasedCount++;
                    status = true;
                }
            }
            logger.LogInformation($"RestoreUnlockAsync: Marked {purchasedCount} products as purchased");

            if (!status)
            {
                logger.LogWarning("RestoreUnlockAsync: No products were successfully restored");
                string message;
                if (status)
                {
                    message = AppResources.InAppPurchase_RestoreSuccessful;
                }
                else
                {
                    var builder = new StringBuilder();
                    builder.AppendLine(AppResources.InAppPurchase_ErrorRestoreActivation);

                    if (isSubscriptionPage)
                    {
                        builder.AppendLine(Environment.NewLine);
                        builder.AppendLine(AppResources.InAppPurchase_ErrorSubscriptionRestore);
                    }

                    message = builder.ToString();
                }

                if (!status)
                    throw new ApplicationException(message);

                return status;
            }

            logger.LogInformation("RestoreUnlockAsync: Completed successfully");
            return true;
        }
        catch (InAppBillingPurchaseException ex)
        {
            logger.LogError(ex, $"RestoreUnlockAsync: InAppBillingPurchaseException - {ex.PurchaseError}: {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, $"RestoreUnlockAsync: Exception - {ex.Message}");
            throw;
        }
        finally
        {
            logger.LogInformation("RestoreUnlockAsync: Disconnecting from store");
            await InAppBillingPlatformWrapper.Implementation.DisconnectAsync();
            logger.LogInformation("RestoreUnlockAsync: Disconnected");
        }
    }

    public async Task AcknowledgeConsumeOpenPurchases()
    {
        logger.LogInformation("AcknowledgeConsumeOpenPurchases: Started");

        var openPurchases = settings.OpenPurchases;
        logger.LogInformation($"AcknowledgeConsumeOpenPurchases: Open purchases count = {openPurchases.Count}");

        if (openPurchases.Any())
        {
            try
            {
                if (!coreService.CanUseInAppPurchases())
                {
                    logger.LogInformation("AcknowledgeConsumeOpenPurchases: InAppPurchases not available, returning");
                    return;
                }

                logger.LogInformation("AcknowledgeConsumeOpenPurchases: Attempting to connect to store");
                var connection = await InAppBillingPlatformWrapper.Implementation.ConnectAsync();
                logger.LogInformation($"AcknowledgeConsumeOpenPurchases: Connection result = {connection}");
                if (!connection)
                {
                    logger.LogWarning("AcknowledgeConsumeOpenPurchases: Failed to connect, returning");
                    return;
                }

                logger.LogInformation("AcknowledgeConsumeOpenPurchases: Calling GetPurchasesAsync(ItemType.InAppPurchase)");
                var purchases = (await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(ItemType.InAppPurchase))?.ToArray();
                logger.LogInformation($"AcknowledgeConsumeOpenPurchases: GetPurchasesAsync(InAppPurchase) returned {purchases?.Length ?? 0} purchases");

                logger.LogInformation("AcknowledgeConsumeOpenPurchases: Calling GetPurchasesAsync(ItemType.Subscription)");
                var subscriptionPurchases = await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(ItemType.Subscription);
                logger.LogInformation($"AcknowledgeConsumeOpenPurchases: GetPurchasesAsync(Subscription) returned {subscriptionPurchases?.Count() ?? 0} purchases");

                purchases = purchases != null ?
                    purchases.Concat(subscriptionPurchases).ToArray() :
                    subscriptionPurchases?.ToArray();

                logger.LogInformation($"AcknowledgeConsumeOpenPurchases: Total purchases = {purchases?.Length ?? 0}");

                if (purchases != null && purchases.Any())
                {
                    logger.LogInformation("AcknowledgeConsumeOpenPurchases: Processing open purchases");
                    await AcknowledgeConsumeOpenPurchases(purchases, openPurchases);
                }
                else
                {
                    logger.LogInformation("AcknowledgeConsumeOpenPurchases: No purchases to process");
                }
            }
            catch (InAppBillingPurchaseException ex)
            {
                logger.LogError(ex, $"AcknowledgeConsumeOpenPurchases: InAppBillingPurchaseException - {ex.PurchaseError}: {ex.Message}");
                throw;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, $"AcknowledgeConsumeOpenPurchases: Exception - {ex.Message}");
                throw;
            }
            finally
            {
                logger.LogInformation("AcknowledgeConsumeOpenPurchases: Disconnecting from store");
                await InAppBillingPlatformWrapper.Implementation.DisconnectAsync();
                logger.LogInformation("AcknowledgeConsumeOpenPurchases: Disconnected");
            }
        }
        else
        {
            logger.LogInformation("AcknowledgeConsumeOpenPurchases: No open purchases to process");
        }
    }

    public async Task<bool> MarkProductAsPurchased(string identifier, bool unlock = true, bool invokePurchaseDone = true)
    {
        logger.LogInformation($"Mark product as purchased {identifier}, {unlock}, {invokePurchaseDone}");

        var unlockMapping = AppPurchaseConfig.InAppPurchaseUnlockMapping;
        if (unlockMapping.ContainsKey(identifier))
        {
            var unlocks = settings.PurchasedUnlocks;
            var changedUnlocks = false;
            var status = false;

            foreach (var unlockToken in unlockMapping[identifier])
            {
                if (unlockToken == AppPurchaseConfig.INAPPPURCHASE_REMOVEADS_TOKEN)
                {
                    settings.RemoveAds = unlock;
                    WeakReferenceMessenger.Default.Send(new AppEvent(AppEvent.OccuredEvent.RemoveAds));
                    status = true;
                }
                else
                {
                    if (unlocks.Add(unlockToken))
                        changedUnlocks = true;

                    status = true;
                }
            }

            if (changedUnlocks)
            {
                settings.PurchasedUnlocks = unlocks;
                settings.IsAboUnlock = AppPurchaseConfig.InAppPurchaseSubscriptionProductIdentifiers.Contains(identifier);
                WeakReferenceMessenger.Default.Send(new AppEvent(AppEvent.OccuredEvent.UnlocksChanged));
            }

            if (invokePurchaseDone)
                await verifyPurchase.PurchaseDone(identifier, unlock).ConfigureAwait(false);

            return status;
        }

        if (invokePurchaseDone)
            await verifyPurchase.PurchaseDone(identifier, unlock).ConfigureAwait(false);

        return AppPurchaseConfig.InAppPurchaseTipProductIdentifiers.Contains(identifier);
    }

    private async Task<bool> AcknowledgeConsumeOpenPurchases(InAppBillingPurchase[] purchases, HashSet<string> openPurchases)
    {
        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Processing {purchases.Length} purchases against {openPurchases.Count} open purchases");
        var state = false;
        var processedCount = 0;

        foreach (var purchase in purchases.Where(p => openPurchases.Contains(p.ProductId)))
        {
            processedCount++;
            logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Processing purchase #{processedCount} - {purchase.ProductId} with state {purchase.State}");

            if (purchase.State == PurchaseState.Purchased || purchase.State == PurchaseState.Restored)
            {
                var success = false;
                if (AppPurchaseConfig.InAppPurchaseTipProductIdentifiers.Contains(purchase.ProductId))
                {
                    logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): {purchase.ProductId} is a tip product");
                    if (DeviceInfo.Current.Platform != DevicePlatform.iOS)
                    {
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Consuming purchase {purchase.ProductId}");
                        var consumedItem = await InAppBillingPlatformWrapper.Implementation.ConsumePurchaseAsync(purchase.ProductId, purchase.PurchaseToken);
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Consume result = {consumedItem}");
                        if (consumedItem)
                            success = true;
                    }
                    else
                    {
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): iOS platform, marking as success");
                        success = true;
                    }
                }
                else
                {
                    logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): {purchase.ProductId} is a regular product");
                    if (DeviceInfo.Current.Platform != DevicePlatform.iOS)
                    {
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Finalizing purchase {purchase.ProductId}");
                        var acknowledged = await InAppBillingPlatformWrapper.Implementation.FinalizePurchaseAsync([purchase.PurchaseToken]);
                        var acknowledgeResult = acknowledged?.FirstOrDefault(r => r.Id == purchase.PurchaseToken).Success ?? false;
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Finalize result = {acknowledgeResult}");
                        if (acknowledgeResult)
                            success = true;
                    }
                    else
                    {
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): iOS platform, marking as success");
                        success = true;
                    }
                }

                if (success)
                {
                    logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Removing {purchase.ProductId} from open purchases and marking as purchased");
                    openPurchases.Remove(purchase.ProductId);
                    if (await MarkProductAsPurchased(purchase.ProductId))
                    {
                        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Successfully marked {purchase.ProductId} as purchased");
                        state = true;
                    }
                }
                else
                {
                    logger.LogWarning($"AcknowledgeConsumeOpenPurchases(private): Failed to acknowledge/consume {purchase.ProductId}");
                }
            }
            else
            {
                logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Skipping {purchase.ProductId} - state is {purchase.State}");
            }
        }

        logger.LogInformation($"AcknowledgeConsumeOpenPurchases(private): Saving open purchases, result state = {state}");
        settings.OpenPurchases = openPurchases;
        return state;
    }
}

And this is the log I got from my app (nothing happens anymore after the last line, no matter how long I wait):

2026-04-27 11:11:39.207 +02:00 [INF] InAppBillingImplementation: Constructor called
2026-04-27 11:11:39.220 +02:00 [INF] Init: Initializing payment observer
2026-04-27 11:11:39.220 +02:00 [INF] PaymentObserver: Created
2026-04-27 11:11:39.221 +02:00 [INF] Init: Payment observer added to SKPaymentQueue
2026-04-27 11:11:39.326 +02:00 [INF] AppState: Start
2026-04-27 11:11:39.328 +02:00 [INF] App Version 2.2.1 (26047) running on iOS 26.4.2
2026-04-27 11:11:39.332 +02:00 [INF] AcknowledgeConsumeOpenPurchases: Started
2026-04-27 11:11:39.337 +02:00 [INF] Loading affiliate count for c6608acb-a801-4f9c-99f3-7b0eeb0ac1ec
2026-04-27 11:11:39.353 +02:00 [INF] Remote notification registered with token 
2026-04-27 11:11:39.367 +02:00 [INF] AcknowledgeConsumeOpenPurchases: Open purchases count = 0
2026-04-27 11:11:39.368 +02:00 [INF] AcknowledgeConsumeOpenPurchases: No open purchases to process
2026-04-27 11:11:39.601 +02:00 [INF] Result for affiliate count: 0
2026-04-27 11:11:41.246 +02:00 [WRN] Warning - Window already had an alert manager subscription, but a new one was requested. Not going to do anything.
2026-04-27 11:11:41.248 +02:00 [INF] GetAllAvailableProductsAsync: Started
2026-04-27 11:11:41.248 +02:00 [INF] GetAllAvailableProductsAsync: Attempting to connect to store
2026-04-27 11:11:41.249 +02:00 [INF] GetAllAvailableProductsAsync: Connection result = True
2026-04-27 11:11:41.252 +02:00 [INF] GetAllAvailableProductsAsync: Normal purchases count = 13, Subscriptions count = 4
2026-04-27 11:11:41.252 +02:00 [INF] GetAllAvailableProductsAsync: Getting product info for InAppPurchase items
2026-04-27 11:11:41.257 +02:00 [INF] GetProductInfoAsync: Started for ItemType=InAppPurchase, ProductIds=com.softwarenotion.tearscompanion.recipes,com.softwarenotion.tearscompanion.compendium,com.softwarenotion.tearscompanion.armor,com.softwarenotion.tearscompanion.weapondetails,com.softwarenotion.tearscompanion.monster,com.softwarenotion.tearscompanion.material,com.softwarenotion.tearscompanion.ageofimprisonment,com.softwarenotion.tearscompanion.allpages,com.softwarenotion.tearscompanion.removeads,com.softwarenotion.tearscompanion.tipglorious,com.softwarenotion.tearscompanion.tipbig,com.softwarenotion.tearscompanion.tipsmall,com.softwarenotion.tearscompanion.tiptiny
2026-04-27 11:11:41.257 +02:00 [INF] Init: Payment observer already initialized, skipping
2026-04-27 11:11:41.257 +02:00 [INF] GetProductInfoAsync: Calling GetProductAsync
2026-04-27 11:11:41.257 +02:00 [INF] GetProductAsync: Creating product request for 13 products
2026-04-27 11:11:41.269 +02:00 [INF] GetProductAsync: Starting SKProductsRequest
2026-04-27 11:11:41.289 +02:00 [WRN] Microsoft.Maui.Controls.TapGestureRecognizer is already a child of Microsoft.Maui.Controls.StackLayout. Remove Microsoft.Maui.Controls.TapGestureRecognizer from Microsoft.Maui.Controls.StackLayout before adding to Microsoft.Maui.Controls.StackLayout.
2026-04-27 11:11:41.289 +02:00 [WRN] Microsoft.Maui.Controls.TapGestureRecognizer is already a child of Microsoft.Maui.Controls.StackLayout. Remove Microsoft.Maui.Controls.TapGestureRecognizer from Microsoft.Maui.Controls.StackLayout before adding to Microsoft.Maui.Controls.Image.
2026-04-27 11:11:41.290 +02:00 [WRN] Microsoft.Maui.Controls.TapGestureRecognizer is already a child of Microsoft.Maui.Controls.StackLayout. Remove Microsoft.Maui.Controls.TapGestureRecognizer from Microsoft.Maui.Controls.StackLayout before adding to Microsoft.Maui.Controls.Image.
2026-04-27 11:11:41.929 +02:00 [INF] ProductRequestDelegate: Received response with 13 products, 0 invalid products
2026-04-27 11:11:41.929 +02:00 [INF] ProductRequestDelegate: Setting result with 13 products
2026-04-27 11:11:41.930 +02:00 [INF] GetProductInfoAsync: Retrieved 13 products
2026-04-27 11:11:41.930 +02:00 [INF] GetProductInfoAsync: Completed successfully
2026-04-27 11:11:41.933 +02:00 [INF] GetAllAvailableProductsAsync: Retrieved 13 InAppPurchase products
2026-04-27 11:11:41.933 +02:00 [INF] GetAllAvailableProductsAsync: Getting product info for Subscription items
2026-04-27 11:11:41.933 +02:00 [INF] GetProductInfoAsync: Started for ItemType=Subscription, ProductIds=com.softwarenotion.tearscompanion.suballfullunlock.monthly,com.softwarenotion.tearscompanion.suballfullunlock.quarterly,com.softwarenotion.tearscompanion.suballfullunlock.halfyearly,com.softwarenotion.tearscompanion.suballfullunlock.yearly
2026-04-27 11:11:41.933 +02:00 [INF] Init: Payment observer already initialized, skipping
2026-04-27 11:11:41.933 +02:00 [INF] GetProductInfoAsync: Calling GetProductAsync
2026-04-27 11:11:41.933 +02:00 [INF] GetProductAsync: Creating product request for 4 products
2026-04-27 11:11:41.933 +02:00 [INF] GetProductAsync: Starting SKProductsRequest
2026-04-27 11:11:42.434 +02:00 [INF] ProductRequestDelegate: Received response with 4 products, 0 invalid products
2026-04-27 11:11:42.434 +02:00 [INF] ProductRequestDelegate: Setting result with 4 products
2026-04-27 11:11:42.434 +02:00 [INF] GetProductInfoAsync: Retrieved 4 products
2026-04-27 11:11:42.434 +02:00 [INF] GetProductInfoAsync: Completed successfully
2026-04-27 11:11:42.436 +02:00 [INF] GetAllAvailableProductsAsync: Total products after subscriptions = 17
2026-04-27 11:11:42.436 +02:00 [INF] GetAllAvailableProductsAsync: Mapping products to PurchasableProduct objects
2026-04-27 11:11:42.437 +02:00 [INF] GetAllAvailableProductsAsync: Completed successfully
2026-04-27 11:11:42.437 +02:00 [INF] GetAllAvailableProductsAsync: Disconnecting from store
2026-04-27 11:11:42.437 +02:00 [INF] GetAllAvailableProductsAsync: Disconnected
2026-04-27 11:11:48.798 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.798 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.798 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.799 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.799 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.799 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.799 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.812 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.812 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.812 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.812 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.812 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.813 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.813 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.819 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.819 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.819 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.819 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.819 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.820 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.820 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.826 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.826 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.826 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.826 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.826 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.827 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:48.827 +02:00 [WRN] Warning - iOS does not support View as the Content property of RadioButton; the return value of the ToString() method will be displayed instead.
2026-04-27 11:11:50.487 +02:00 [INF] Start restoring purchases...
2026-04-27 11:11:50.523 +02:00 [INF] RestoreUnlockAsync: Started (isSubscriptionPage = True)
2026-04-27 11:11:50.523 +02:00 [INF] RestoreUnlockAsync: Attempting to connect to store
2026-04-27 11:11:50.523 +02:00 [INF] RestoreUnlockAsync: Connection result = True
2026-04-27 11:11:50.523 +02:00 [INF] RestoreUnlockAsync: Calling GetPurchasesAsync(ItemType.InAppPurchase)
2026-04-27 11:11:50.523 +02:00 [INF] GetPurchasesAsync: Started for ItemType=InAppPurchase
2026-04-27 11:11:50.523 +02:00 [INF] Init: Payment observer already initialized, skipping
2026-04-27 11:11:50.523 +02:00 [INF] GetPurchasesAsync: Calling RestoreAsync
2026-04-27 11:11:50.523 +02:00 [INF] RestoreAsync: Started
2026-04-27 11:11:50.524 +02:00 [INF] RestoreAsync: Added TransactionsRestored handler
2026-04-27 11:11:50.524 +02:00 [INF] RestoreAsync: Enumerating existing transactions in DefaultQueue
2026-04-27 11:11:50.524 +02:00 [INF] RestoreAsync: Found 0 existing transactions before restore
2026-04-27 11:11:50.524 +02:00 [INF] RestoreAsync: Calling SKPaymentQueue.DefaultQueue.RestoreCompletedTransactions()
2026-04-27 11:11:50.524 +02:00 [INF] RestoreAsync: Waiting for restoration to complete
2026-04-27 11:11:52.675 +02:00 [INF] PaymentObserver: RestoreCompletedTransactionsFinished called with 0 restored transactions
2026-04-27 11:11:52.676 +02:00 [INF] PaymentObserver: Invoking TransactionsRestored event with 0 transactions
2026-04-27 11:11:52.676 +02:00 [INF] RestoreAsync: Handler invoked with 0 transactions
2026-04-27 11:11:52.676 +02:00 [INF] RestoreAsync: Adding 0 transactions to result
2026-04-27 11:11:52.677 +02:00 [INF] RestoreAsync: Restoration completed with 0 total transactions
2026-04-27 11:11:52.677 +02:00 [INF] RestoreAsync: Removing TransactionsRestored handler
2026-04-27 11:11:52.678 +02:00 [INF] GetPurchasesAsync: RestoreAsync returned 0 purchases
2026-04-27 11:11:52.679 +02:00 [INF] GetPurchasesAsync: Completed with 0 distinct purchases
2026-04-27 11:11:52.680 +02:00 [INF] RestoreUnlockAsync: GetPurchasesAsync(InAppPurchase) returned 0 purchases
2026-04-27 11:11:52.680 +02:00 [INF] RestoreUnlockAsync: Calling GetPurchasesAsync(ItemType.Subscription)
2026-04-27 11:11:52.680 +02:00 [INF] GetPurchasesAsync: Started for ItemType=Subscription
2026-04-27 11:11:52.680 +02:00 [INF] Init: Payment observer already initialized, skipping
2026-04-27 11:11:52.680 +02:00 [INF] GetPurchasesAsync: Calling RestoreAsync
2026-04-27 11:11:52.680 +02:00 [INF] RestoreAsync: Started
2026-04-27 11:11:52.680 +02:00 [INF] RestoreAsync: Added TransactionsRestored handler
2026-04-27 11:11:52.680 +02:00 [INF] RestoreAsync: Enumerating existing transactions in DefaultQueue
2026-04-27 11:11:52.682 +02:00 [INF] RestoreAsync: Found 13 existing transactions before restore
2026-04-27 11:11:52.682 +02:00 [INF] RestoreAsync: Calling SKPaymentQueue.DefaultQueue.RestoreCompletedTransactions()
2026-04-27 11:11:52.682 +02:00 [INF] RestoreAsync: Waiting for restoration to complete
2026-04-27 11:11:52.682 +02:00 [INF] PaymentObserver: Auto-finishing 0 restored transactions
2026-04-27 11:11:52.682 +02:00 [INF] PaymentObserver: UpdatedTransactions called with 13 transactions
2026-04-27 11:11:52.683 +02:00 [INF] PaymentObserver: Found 13 restored transactions, adding to list
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction 2000001160718672 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718672
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction 2000001160718673 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718673
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction 2000001160718674 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718674
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction 2000001160718675 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.684 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718675
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718676 for product com.softwarenotion.tearscompanion.compendium - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718676
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718677 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718677
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718678 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718678
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718679 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718679
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718680 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718680
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718681 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718681
2026-04-27 11:11:52.685 +02:00 [INF] PaymentObserver: Transaction 2000001160718682 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718682
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Transaction 2000001160718683 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718683
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Transaction 2000001160718684 for product com.softwarenotion.tearscompanion.suballfullunlock.monthly - State: Restored
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Transaction Restored, invoking TransactionCompleted
2026-04-27 11:11:52.686 +02:00 [INF] PaymentObserver: Auto-finishing transaction 2000001160718684

Based on that, the last call in my app side is line 398 -> var subscriptionPurchases = await InAppBillingPlatformWrapper.Implementation.GetPurchasesAsync(ItemType.Subscription);

Uh oh!

GetPurchasesAsync(ItemType.Subscription) causes deadlock since a few days #679

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions