@metamask/subscription-controller 8.0.1 → 9.0.0

package/dist/{SubscriptionController.mjs → SubscriptionController.js}

@@ -1,14 +1,11 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SubscriptionController_instances, _SubscriptionController_getSubscriptionPriceAmount, _SubscriptionController_getSubscriptionBalanceAmount, _SubscriptionController_getProductPriceByProductAndPlan, _SubscriptionController_assertValidSubscriptionStateForCryptoApproval, _SubscriptionController_assertIsUserNotSubscribed, _SubscriptionController_assertIsUserSubscribed, _SubscriptionController_assertIsPaymentMethodCrypto, _SubscriptionController_getIsEligibleForTrialedSponsorship, _SubscriptionController_getIsTrialRequested, _SubscriptionController_findCryptoPaymentMethod, _SubscriptionController_resolveCryptoPaymentMethodDefaults, _SubscriptionController_getChainSupportsSponsorship, _SubscriptionController_areTrialedProductsEqual, _SubscriptionController_areSubscriptionsEqual, _SubscriptionController_isSubscriptionEqual, _SubscriptionController_stringifySubscription;
-import { StaticIntervalPollingController } from "@metamask/polling-controller";
-import { TransactionType } from "@metamask/transaction-controller";
-import { BigNumber } from "bignumber.js";
-import { ACTIVE_SUBSCRIPTION_STATUSES, controllerName, DEFAULT_POLLING_INTERVAL, SubscriptionControllerErrorMessage } from "./constants.mjs";
-import { CRYPTO_AUTH_METHODS, PAYMENT_TYPES, PRODUCT_TYPES, SUBSCRIPTION_STATUSES } from "./types.mjs";
+import { StaticIntervalPollingController } from '@metamask/polling-controller';
+import { TransactionType } from '@metamask/transaction-controller';
+import { BigNumber } from 'bignumber.js';
+import deepEqual from 'fast-deep-equal';
+import { ACTIVE_SUBSCRIPTION_STATUSES, controllerName, DEFAULT_POLLING_INTERVAL, SubscriptionControllerErrorMessage, } from './constants.js';
+import { createModuleLogger, projectLogger } from './logger.js';
+import { CRYPTO_AUTH_METHODS, PAYMENT_TYPES, PRODUCT_TYPES, SUBSCRIPTION_STATUSES, } from './types.js';
+const log = createModuleLogger(projectLogger, controllerName);
 /**
  * Get the default state for the Subscription Controller.
  *
@@ -34,6 +31,12 @@ const subscriptionControllerMetadata = {
         includeInDebugSnapshot: false,
         usedInUi: true,
     },
+    productEntitlements: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
     lastSubscription: {
         includeInStateLogs: false,
         persist: true,
@@ -64,6 +67,12 @@ const subscriptionControllerMetadata = {
         includeInDebugSnapshot: true,
         usedInUi: true,
     },
+    benefits: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
     lastSelectedPaymentMethod: {
         includeInStateLogs: false,
         persist: true,
@@ -74,6 +83,7 @@ const subscriptionControllerMetadata = {
 const MESSENGER_EXPOSED_METHODS = [
     'getPricing',
     'getSubscriptions',
+    'getBenefits',
     'getSubscriptionByProduct',
     'getSubscriptionsEligibilities',
     'cancelSubscription',
@@ -116,7 +126,6 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             },
             messenger,
         });
-        _SubscriptionController_instances.add(this);
         this.setIntervalLength(pollingInterval);
         this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
     }
@@ -133,38 +142,95 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         return pricing;
     }
     async getSubscriptions() {
+        return await this.#getSubscriptions();
+    }
+    async #getSubscriptions({ refreshBenefits = true, } = {}) {
         const currentSubscriptions = this.state.subscriptions;
         const currentTrialedProducts = this.state.trialedProducts;
         const currentCustomerId = this.state.customerId;
         const currentLastSubscription = this.state.lastSubscription;
         const currentRewardAccountId = this.state.rewardAccountId;
-        const { customerId: newCustomerId, subscriptions: newSubscriptions, trialedProducts: newTrialedProducts, lastSubscription: newLastSubscription, rewardAccountId: newRewardAccountId, } = await this.messenger.call('SubscriptionService:getSubscriptions');
-        // check if the new subscriptions are different from the current subscriptions
-        const areSubscriptionsEqual = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_areSubscriptionsEqual).call(this, currentSubscriptions, newSubscriptions);
-        // check if the new trialed products are different from the current trialed products
-        const areTrialedProductsEqual = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_areTrialedProductsEqual).call(this, currentTrialedProducts, newTrialedProducts);
-        // check if the new last subscription is different from the current last subscription
-        const isLastSubscriptionEqual = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_isSubscriptionEqual).call(this, currentLastSubscription, newLastSubscription);
+        const currentProductEntitlements = this.state.productEntitlements;
+        const currentSubscriptionState = {
+            customerId: currentCustomerId,
+            subscriptions: currentSubscriptions,
+            trialedProducts: currentTrialedProducts,
+            lastSubscription: currentLastSubscription,
+            rewardAccountId: currentRewardAccountId,
+            productEntitlements: currentProductEntitlements,
+        };
+        const newSubscriptionState = await this.messenger.call('SubscriptionService:getSubscriptions');
+        this.#updateSubscriptionStateIfChanged(currentSubscriptionState, newSubscriptionState);
+        await this.#refreshBenefitsIfActive(refreshBenefits);
+        return newSubscriptionState.subscriptions;
+    }
+    /**
+     * Updates the subscription state and refreshes the access token when the
+     * fetched subscription state differs from the current state.
+     *
+     * @param currentState - The subscription state captured before the request.
+     * @param newState - The subscription state returned by the service.
+     */
+    #updateSubscriptionStateIfChanged(currentState, newState) {
+        const { subscriptions: currentSubscriptions, trialedProducts: currentTrialedProducts, customerId: currentCustomerId, lastSubscription: currentLastSubscription, rewardAccountId: currentRewardAccountId, productEntitlements: currentProductEntitlements, } = currentState;
+        const { customerId: newCustomerId, subscriptions: newSubscriptions, trialedProducts: newTrialedProducts, lastSubscription: newLastSubscription, rewardAccountId: newRewardAccountId, productEntitlements: newProductEntitlements, } = newState;
+        const areSubscriptionsEqual = this.#areSubscriptionsEqual(currentSubscriptions, newSubscriptions);
+        const areTrialedProductsEqual = this.#areTrialedProductsEqual(currentTrialedProducts, newTrialedProducts);
+        const isLastSubscriptionEqual = this.#isSubscriptionEqual(currentLastSubscription, newLastSubscription);
         const areCustomerIdsEqual = currentCustomerId === newCustomerId;
         const areRewardAccountIdsEqual = currentRewardAccountId === newRewardAccountId;
+        const areProductEntitlementsEqual = this.#areProductEntitlementsEqual(currentProductEntitlements, newProductEntitlements);
         // only update the state if the subscriptions or trialed products are different
         // this prevents unnecessary state updates events, easier for the clients to handle
+        // Only update the state if any subscription-related field changed. This
+        // prevents unnecessary state change events for clients to handle.
         if (!areSubscriptionsEqual ||
             !isLastSubscriptionEqual ||
             !areTrialedProductsEqual ||
             !areCustomerIdsEqual ||
-            !areRewardAccountIdsEqual) {
+            !areRewardAccountIdsEqual ||
+            !areProductEntitlementsEqual) {
             this.update((state) => {
                 state.subscriptions = newSubscriptions;
                 state.customerId = newCustomerId;
                 state.trialedProducts = newTrialedProducts;
                 state.lastSubscription = newLastSubscription;
                 state.rewardAccountId = newRewardAccountId;
+                // Omitted entitlements are an empty map so selectors fail closed
+                // instead of keeping last-known paid-feature flags.
+                state.productEntitlements = newProductEntitlements ?? {};
             });
-            // trigger access token refresh to ensure the user has the latest access token if subscription state change
+            // Trigger an access token refresh to ensure the user has the latest
+            // access token after a subscription state change.
             this.triggerAccessTokenRefresh();
         }
-        return newSubscriptions;
+    }
+    /**
+     * Gets and stores the user's subscription benefits.
+     *
+     * @returns The benefits response.
+     * @throws If the user is not an active Money Account Plus subscriber or is
+     * not eligible for benefits.
+     */
+    async getBenefits() {
+        this.#assertIsActiveMoneyAccountPlusSubscriber();
+        const benefits = await this.messenger.call('SubscriptionService:getBenefits');
+        // The subscription may have become inactive while the benefits request
+        // was in flight. Re-check before persisting the response so stale
+        // benefits cannot be restored after entitlement ends.
+        this.#assertIsActiveMoneyAccountPlusSubscriber();
+        this.update((state) => {
+            state.benefits = benefits.eligible
+                ? {
+                    billingPeriodId: benefits.billingPeriodId,
+                    ...benefits.products,
+                }
+                : undefined;
+        });
+        if (!benefits.eligible) {
+            throw new Error(SubscriptionControllerErrorMessage.UserNotSubscribed);
+        }
+        return benefits;
     }
     /**
      * Get the subscription by product.
@@ -185,17 +251,18 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         return await this.messenger.call('SubscriptionService:getSubscriptionsEligibilities', request);
     }
     async cancelSubscription(request) {
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
+        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
         const cancelledSubscription = await this.messenger.call('SubscriptionService:cancelSubscription', request);
         this.update((state) => {
             state.subscriptions = state.subscriptions.map((subscription) => subscription.id === request.subscriptionId
                 ? { ...subscription, ...cancelledSubscription }
                 : subscription);
         });
+        await this.#refreshBenefitsIfActive();
         this.triggerAccessTokenRefresh();
     }
     async unCancelSubscription(request) {
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
+        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
         const uncancelledSubscription = await this.messenger.call('SubscriptionService:unCancelSubscription', {
             subscriptionId: request.subscriptionId,
         });
@@ -204,6 +271,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
                 ? { ...subscription, ...uncancelledSubscription }
                 : subscription);
         });
+        await this.#refreshBenefitsIfActive();
         this.triggerAccessTokenRefresh();
     }
     /**
@@ -219,10 +287,10 @@ export class SubscriptionController extends StaticIntervalPollingController() {
     async startSubscriptionWithCard(request) {
         // get the latest subscriptions state before computing trial eligibility
         await this.getSubscriptions();
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
+        this.#assertIsUserNotSubscribed({ products: request.products });
         const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCard', {
             ...request,
-            isTrialRequested: __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, request.products, request.recurringInterval),
+            isTrialRequested: this.#getIsTrialRequested(request.products, request.recurringInterval),
         });
         // note: no need to trigger access token refresh after startSubscriptionWithCard request because this only return stripe checkout session url, subscription not created yet
         return response;
@@ -245,11 +313,11 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             throw new Error(SubscriptionControllerErrorMessage.SubscriptionProductsEmpty);
         }
         // get the latest subscriptions state before computing trial eligibility
-        await this.getSubscriptions();
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
+        await this.#getSubscriptions({ refreshBenefits: false });
+        this.#assertIsUserNotSubscribed({ products: request.products });
         const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCrypto', {
             ...request,
-            isTrialRequested: __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, request.products, request.recurringInterval),
+            isTrialRequested: this.#getIsTrialRequested(request.products, request.recurringInterval),
         });
         // Crypto start creates the subscription immediately (unlike card checkout).
         await this.getSubscriptions();
@@ -297,13 +365,13 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             throw new Error('Last selected payment method not found');
         }
         const lastSelectedPaymentMethodForProduct = lastSelectedPaymentMethod[productType];
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsPaymentMethodCrypto).call(this, lastSelectedPaymentMethodForProduct);
-        const productPrice = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getProductPriceByProductAndPlan).call(this, productType, lastSelectedPaymentMethodForProduct.plan);
+        this.#assertIsPaymentMethodCrypto(lastSelectedPaymentMethodForProduct);
+        const productPrice = this.#getProductPriceByProductAndPlan(productType, lastSelectedPaymentMethodForProduct.plan);
         // get the latest subscriptions state before computing trial eligibility
-        await this.getSubscriptions();
-        const isTrialRequested = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, [productType], lastSelectedPaymentMethodForProduct.plan);
+        await this.#getSubscriptions({ refreshBenefits: false });
+        const isTrialRequested = this.#getIsTrialRequested([productType], lastSelectedPaymentMethodForProduct.plan);
         const currentSubscription = this.getSubscriptionByProduct(productType);
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertValidSubscriptionStateForCryptoApproval).call(this, {
+        this.#assertValidSubscriptionStateForCryptoApproval({
             productType,
         });
         // if subscription exists, this transaction is for changing payment method
@@ -338,7 +406,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             await this.startSubscriptionWithCrypto(params);
         }
         // update the subscriptions state after subscription created in server
-        await this.getSubscriptions();
+        await this.#getSubscriptions({ refreshBenefits: false });
     }
     /**
      * Get transaction params to create crypto approve transaction for subscription payment
@@ -363,7 +431,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (!price) {
             throw new Error('Price not found');
         }
-        const chainsPaymentInfo = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_findCryptoPaymentMethod).call(this, request.productType, CRYPTO_AUTH_METHODS.ERC20_APPROVAL);
+        const chainsPaymentInfo = this.#findCryptoPaymentMethod(request.productType, CRYPTO_AUTH_METHODS.ERC20_APPROVAL);
         if (!chainsPaymentInfo) {
             throw new Error('Chains payment info not found');
         }
@@ -461,17 +529,17 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (request.products.length === 0) {
             throw new Error(SubscriptionControllerErrorMessage.SubscriptionProductsEmpty);
         }
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
+        this.#assertIsUserNotSubscribed({ products: request.products });
         const selectedPaymentMethod = this.state.lastSelectedPaymentMethod?.[request.products[0]];
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsPaymentMethodCrypto).call(this, selectedPaymentMethod);
+        this.#assertIsPaymentMethodCrypto(selectedPaymentMethod);
         const cryptoAuthMethod = selectedPaymentMethod.cryptoAuthMethod ??
             CRYPTO_AUTH_METHODS.ERC20_APPROVAL;
-        const isEligibleForTrialedSponsorship = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsEligibleForTrialedSponsorship).call(this, request.chainId, request.products, cryptoAuthMethod);
+        const isEligibleForTrialedSponsorship = this.#getIsEligibleForTrialedSponsorship(request.chainId, request.products, cryptoAuthMethod);
         if (!isEligibleForTrialedSponsorship) {
             return false;
         }
         const { paymentTokenSymbol, plan } = selectedPaymentMethod;
-        const productPrice = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getProductPriceByProductAndPlan).call(this, 
+        const productPrice = this.#getProductPriceByProductAndPlan(
         // we only support one product at a time for now
         request.products[0], plan);
         const billingCycles = productPrice.minBillingCycles;
@@ -512,7 +580,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
      */
     async linkRewards(request) {
         // assert that the user is subscribed to the subscription
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
+        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
         // link rewards to the subscription
         const response = await this.messenger.call('SubscriptionService:linkRewards', {
             rewardAccountId: request.rewardAccountId,
@@ -524,6 +592,54 @@ export class SubscriptionController extends StaticIntervalPollingController() {
     async _executePoll() {
         await this.getSubscriptions();
     }
+    async #refreshBenefitsIfActive(refreshBenefits = true) {
+        if (!this.#hasActiveMoneyAccountPlusSubscription()) {
+            if (this.state.benefits) {
+                this.update((state) => {
+                    state.benefits = undefined;
+                });
+            }
+            return;
+        }
+        if (!refreshBenefits) {
+            return;
+        }
+        try {
+            await this.getBenefits();
+        }
+        catch (error) {
+            log('Failed to refresh subscription benefits', error);
+        }
+    }
+    /**
+     * Calculate total subscription price amount (approval amount) from price info
+     * e.g: $8 per month * 12 months min billing cycles = $96
+     *
+     * @param price - The price info
+     * @returns The price amount
+     */
+    #getSubscriptionPriceAmount(price) {
+        // no need to use BigInt since max unitDecimals are always 2 for price
+        const amount = new BigNumber(price.unitAmount)
+            .div(10 ** price.unitDecimals)
+            .multipliedBy(price.minBillingCycles)
+            .toString();
+        return amount;
+    }
+    /**
+     * Calculate minimum subscription balance amount from price info
+     *
+     * @param price - The price info
+     * @returns The balance amount
+     */
+    #getSubscriptionBalanceAmount(price) {
+        // no need to use BigInt since max unitDecimals are always 2 for price
+        const amount = new BigNumber(price.unitAmount)
+            .div(10 ** price.unitDecimals)
+            .multipliedBy(price.minBillingCyclesForBalance)
+            .toString();
+        return amount;
+    }
     /**
      * Calculate token approve amount from price info
      *
@@ -537,7 +653,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             throw new Error('Conversion rate not found');
         }
         // price of the product
-        const priceAmount = new BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionPriceAmount).call(this, price));
+        const priceAmount = new BigNumber(this.#getSubscriptionPriceAmount(price));
         const tokenDecimal = new BigNumber(10).pow(tokenPaymentInfo.decimals);
         const tokenAmount = priceAmount
             .multipliedBy(tokenDecimal)
@@ -556,7 +672,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (!conversionRate) {
             throw new Error('Conversion rate not found');
         }
-        const balanceAmount = new BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionBalanceAmount).call(this, price));
+        const balanceAmount = new BigNumber(this.#getSubscriptionBalanceAmount(price));
         const tokenDecimal = new BigNumber(10).pow(tokenPaymentInfo.decimals);
         const tokenAmount = balanceAmount
             .multipliedBy(tokenDecimal)
@@ -581,159 +697,244 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         // will be fetched.
         this.messenger.call('AuthenticationController:performSignOut');
     }
-}
-_SubscriptionController_instances = new WeakSet(), _SubscriptionController_getSubscriptionPriceAmount = function _SubscriptionController_getSubscriptionPriceAmount(price) {
-    // no need to use BigInt since max unitDecimals are always 2 for price
-    const amount = new BigNumber(price.unitAmount)
-        .div(10 ** price.unitDecimals)
-        .multipliedBy(price.minBillingCycles)
-        .toString();
-    return amount;
-}, _SubscriptionController_getSubscriptionBalanceAmount = function _SubscriptionController_getSubscriptionBalanceAmount(price) {
-    // no need to use BigInt since max unitDecimals are always 2 for price
-    const amount = new BigNumber(price.unitAmount)
-        .div(10 ** price.unitDecimals)
-        .multipliedBy(price.minBillingCyclesForBalance)
-        .toString();
-    return amount;
-}, _SubscriptionController_getProductPriceByProductAndPlan = function _SubscriptionController_getProductPriceByProductAndPlan(productType, plan) {
-    const { pricing } = this.state;
-    const productPricing = pricing?.products.find((product) => product.name === productType);
-    const productPrice = productPricing?.prices.find((price) => price.interval === plan);
-    if (!productPrice) {
-        throw new Error(SubscriptionControllerErrorMessage.ProductPriceNotFound);
-    }
-    return productPrice;
-}, _SubscriptionController_assertValidSubscriptionStateForCryptoApproval = function _SubscriptionController_assertValidSubscriptionStateForCryptoApproval({ productType, }) {
-    const subscription = this.state.subscriptions.find((sub) => sub.products.some((product) => product.name === productType));
-    const isValid = !subscription ||
-        [
-            SUBSCRIPTION_STATUSES.pastDue,
-            SUBSCRIPTION_STATUSES.unpaid,
-            SUBSCRIPTION_STATUSES.paused,
-            SUBSCRIPTION_STATUSES.provisional,
-            SUBSCRIPTION_STATUSES.active,
-            SUBSCRIPTION_STATUSES.trialing,
-        ].includes(subscription.status);
-    if (!isValid) {
-        throw new Error(SubscriptionControllerErrorMessage.SubscriptionNotValidForCryptoApproval);
-    }
-}, _SubscriptionController_assertIsUserNotSubscribed = function _SubscriptionController_assertIsUserNotSubscribed({ products }) {
-    const subscription = this.state.subscriptions.find((sub) => sub.products.some((product) => products.includes(product.name)));
-    if (subscription &&
-        ACTIVE_SUBSCRIPTION_STATUSES.includes(subscription.status)) {
-        throw new Error(SubscriptionControllerErrorMessage.UserAlreadySubscribed);
-    }
-}, _SubscriptionController_assertIsUserSubscribed = function _SubscriptionController_assertIsUserSubscribed(request) {
-    if (!this.state.subscriptions.find((subscription) => subscription.id === request.subscriptionId)) {
-        throw new Error(SubscriptionControllerErrorMessage.UserNotSubscribed);
-    }
-}, _SubscriptionController_assertIsPaymentMethodCrypto = function _SubscriptionController_assertIsPaymentMethodCrypto(value) {
-    if (value?.type !== PAYMENT_TYPES.byCrypto ||
-        !value.paymentTokenAddress ||
-        !value.paymentTokenSymbol) {
-        throw new Error(SubscriptionControllerErrorMessage.PaymentMethodNotCrypto);
-    }
-}, _SubscriptionController_getIsEligibleForTrialedSponsorship = function _SubscriptionController_getIsEligibleForTrialedSponsorship(chainId, products, cryptoAuthMethod) {
-    const isSponsorshipSupported = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getChainSupportsSponsorship).call(this, chainId, products[0], cryptoAuthMethod);
-    // verify if the user has trialed the provided products before
-    const hasTrialedBefore = this.state.trialedProducts.some((product) => products.includes(product));
-    return isSponsorshipSupported && !hasTrialedBefore;
-}, _SubscriptionController_getIsTrialRequested = function _SubscriptionController_getIsTrialRequested(products, plan) {
-    return products.every((productType) => {
-        if (this.state.trialedProducts.includes(productType)) {
-            return false;
+    #getProductPriceByProductAndPlan(productType, plan) {
+        const { pricing } = this.state;
+        const productPricing = pricing?.products.find((product) => product.name === productType);
+        const productPrice = productPricing?.prices.find((price) => price.interval === plan);
+        if (!productPrice) {
+            throw new Error(SubscriptionControllerErrorMessage.ProductPriceNotFound);
         }
-        const productPrice = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getProductPriceByProductAndPlan).call(this, productType, plan);
-        return productPrice.trialPeriodDays > 0;
-    });
-}, _SubscriptionController_findCryptoPaymentMethod = function _SubscriptionController_findCryptoPaymentMethod(productType, cryptoAuthMethod) {
-    const matches = [];
-    for (const paymentMethod of this.state.pricing?.paymentMethods ?? []) {
-        if (paymentMethod.type !== PAYMENT_TYPES.byCrypto) {
-            continue;
-        }
-        const resolved = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_resolveCryptoPaymentMethodDefaults).call(this, paymentMethod);
-        if (!resolved) {
-            continue;
-        }
-        if (resolved.cryptoAuthMethod === cryptoAuthMethod &&
-            resolved.products.includes(productType)) {
-            matches.push({
-                method: paymentMethod,
-                explicit: resolved.explicit,
-            });
+        return productPrice;
+    }
+    #assertValidSubscriptionStateForCryptoApproval({ productType, }) {
+        const subscription = this.state.subscriptions.find((sub) => sub.products.some((product) => product.name === productType));
+        const isValid = !subscription ||
+            [
+                SUBSCRIPTION_STATUSES.pastDue,
+                SUBSCRIPTION_STATUSES.unpaid,
+                SUBSCRIPTION_STATUSES.paused,
+                SUBSCRIPTION_STATUSES.provisional,
+                SUBSCRIPTION_STATUSES.active,
+                SUBSCRIPTION_STATUSES.trialing,
+            ].includes(subscription.status);
+        if (!isValid) {
+            throw new Error(SubscriptionControllerErrorMessage.SubscriptionNotValidForCryptoApproval);
+        }
+    }
+    #assertIsUserNotSubscribed({ products }) {
+        const subscription = this.state.subscriptions.find((sub) => sub.products.some((product) => products.includes(product.name)));
+        if (subscription &&
+            ACTIVE_SUBSCRIPTION_STATUSES.includes(subscription.status)) {
+            throw new Error(SubscriptionControllerErrorMessage.UserAlreadySubscribed);
+        }
+    }
+    #assertIsActiveMoneyAccountPlusSubscriber() {
+        if (!this.#hasActiveMoneyAccountPlusSubscription()) {
+            if (this.state.benefits) {
+                this.update((state) => {
+                    state.benefits = undefined;
+                });
+            }
+            throw new Error(SubscriptionControllerErrorMessage.UserNotSubscribed);
+        }
+    }
+    #assertIsUserSubscribed(request) {
+        if (!this.state.subscriptions.find((subscription) => subscription.id === request.subscriptionId)) {
+            throw new Error(SubscriptionControllerErrorMessage.UserNotSubscribed);
+        }
+    }
+    /**
+     * Asserts that the value is a valid crypto payment method.
+     *
+     * After this assert, `cryptoAuthMethod` and `useTestClock` remain optional
+     * because persisted cache entries may omit them.
+     *
+     * @param value - The value to assert.
+     * @throws an error if the value is not a valid crypto payment method.
+     */
+    #assertIsPaymentMethodCrypto(value) {
+        if (value?.type !== PAYMENT_TYPES.byCrypto ||
+            !value.paymentTokenAddress ||
+            !value.paymentTokenSymbol) {
+            throw new Error(SubscriptionControllerErrorMessage.PaymentMethodNotCrypto);
         }
     }
-    if (matches.length === 0) {
-        return undefined;
+    #hasActiveMoneyAccountPlusSubscription() {
+        return this.state.subscriptions.some((subscription) => subscription.products.some((product) => product.name === PRODUCT_TYPES.MONEY_ACCOUNT_PLUS) && ACTIVE_SUBSCRIPTION_STATUSES.includes(subscription.status));
     }
-    const explicitMatches = matches.filter((match) => match.explicit);
-    const candidates = explicitMatches.length > 0 ? explicitMatches : matches;
-    if (candidates.length > 1) {
-        throw new Error('Multiple matching crypto payment methods found');
+    /**
+     * Determines if the user is eligible for trialed sponsorship for the given chain and products.
+     * The user is eligible if the chain supports sponsorship and the user has not trialed the provided products before.
+     *
+     * @param chainId - The chain ID
+     * @param products - The products to check eligibility for
+     * @param cryptoAuthMethod - The crypto authorization method of the selected payment method
+     * @returns True if the user is eligible for trialed sponsorship, false otherwise
+     */
+    #getIsEligibleForTrialedSponsorship(chainId, products, cryptoAuthMethod) {
+        const isSponsorshipSupported = this.#getChainSupportsSponsorship(chainId, products[0], cryptoAuthMethod);
+        // verify if the user has trialed the provided products before
+        const hasTrialedBefore = this.state.trialedProducts.some((product) => products.includes(product));
+        return isSponsorshipSupported && !hasTrialedBefore;
     }
-    return candidates[0].method;
-}, _SubscriptionController_resolveCryptoPaymentMethodDefaults = function _SubscriptionController_resolveCryptoPaymentMethodDefaults(paymentMethod) {
-    const productsPresent = paymentMethod.products !== undefined;
-    const authPresent = paymentMethod.cryptoAuthMethod !== undefined;
-    if (!productsPresent && !authPresent) {
+    /**
+     * Whether a trial should be requested for the given products and plan.
+     * True only when every product has `trialPeriodDays > 0` and has not
+     * already been trialed.
+     *
+     * @param products - The products to check.
+     * @param plan - The recurring interval to look up pricing for.
+     * @returns Whether a trial should be requested.
+     */
+    #getIsTrialRequested(products, plan) {
+        return products.every((productType) => {
+            if (this.state.trialedProducts.includes(productType)) {
+                return false;
+            }
+            const productPrice = this.#getProductPriceByProductAndPlan(productType, plan);
+            return productPrice.trialPeriodDays > 0;
+        });
+    }
+    #findCryptoPaymentMethod(productType, cryptoAuthMethod) {
+        const matches = [];
+        for (const paymentMethod of this.state.pricing?.paymentMethods ?? []) {
+            if (paymentMethod.type !== PAYMENT_TYPES.byCrypto) {
+                continue;
+            }
+            const resolved = this.#resolveCryptoPaymentMethodDefaults(paymentMethod);
+            if (!resolved) {
+                continue;
+            }
+            if (resolved.cryptoAuthMethod === cryptoAuthMethod &&
+                resolved.products.includes(productType)) {
+                matches.push({
+                    method: paymentMethod,
+                    explicit: resolved.explicit,
+                });
+            }
+        }
+        if (matches.length === 0) {
+            return undefined;
+        }
+        const explicitMatches = matches.filter((match) => match.explicit);
+        const candidates = explicitMatches.length > 0 ? explicitMatches : matches;
+        if (candidates.length > 1) {
+            throw new Error('Multiple matching crypto payment methods found');
+        }
+        return candidates[0].method;
+    }
+    /**
+     * Resolves omitted `products` / `cryptoAuthMethod` on a crypto pricing row.
+     * Legacy Shield + `erc20_approval` defaults apply only when both fields are
+     * absent. If `products` is present, the list must be non-empty and
+     * `cryptoAuthMethod` must be explicit; otherwise the row is ignored.
+     *
+     * @param paymentMethod - The crypto pricing row.
+     * @returns Resolved products and auth method, or `undefined` if the row is
+     * incomplete.
+     */
+    #resolveCryptoPaymentMethodDefaults(paymentMethod) {
+        const productsPresent = paymentMethod.products !== undefined;
+        const authPresent = paymentMethod.cryptoAuthMethod !== undefined;
+        if (!productsPresent && !authPresent) {
+            return {
+                products: [PRODUCT_TYPES.SHIELD],
+                cryptoAuthMethod: CRYPTO_AUTH_METHODS.ERC20_APPROVAL,
+                explicit: false,
+            };
+        }
+        if (!paymentMethod.products?.length || !paymentMethod.cryptoAuthMethod) {
+            return undefined;
+        }
         return {
-            products: [PRODUCT_TYPES.SHIELD],
-            cryptoAuthMethod: CRYPTO_AUTH_METHODS.ERC20_APPROVAL,
-            explicit: false,
+            products: paymentMethod.products,
+            cryptoAuthMethod: paymentMethod.cryptoAuthMethod,
+            explicit: true,
         };
     }
-    if (!paymentMethod.products?.length || !paymentMethod.cryptoAuthMethod) {
-        return undefined;
+    /**
+     * Whether the given chain supports sponsorship for the product and auth method.
+     *
+     * @param chainId - The chain ID
+     * @param productType - The product type
+     * @param cryptoAuthMethod - The crypto authorization method to look up
+     * @returns True if the chain row has sponsorship enabled, false if it is explicitly not sponsored
+     * @throws If the crypto payment method or chain row is missing from pricing
+     */
+    #getChainSupportsSponsorship(chainId, productType, cryptoAuthMethod) {
+        const cryptoPaymentInfo = this.#findCryptoPaymentMethod(productType, cryptoAuthMethod);
+        if (!cryptoPaymentInfo) {
+            throw new Error('Chains payment info not found');
+        }
+        const chainPaymentInfo = cryptoPaymentInfo.chains?.find((chain) => chain.chainId === chainId);
+        if (!chainPaymentInfo) {
+            throw new Error('Invalid chain id');
+        }
+        return Boolean(chainPaymentInfo.isSponsorshipSupported);
+    }
+    /**
+     * Determines whether two trialed products arrays are equal by comparing all products in the arrays.
+     *
+     * @param oldTrialedProducts - The first trialed products array to compare.
+     * @param newTrialedProducts - The second trialed products array to compare.
+     * @returns True if the trialed products arrays are equal, false otherwise.
+     */
+    #areTrialedProductsEqual(oldTrialedProducts, newTrialedProducts) {
+        return (oldTrialedProducts.length === newTrialedProducts?.length &&
+            oldTrialedProducts.every((product) => newTrialedProducts?.includes(product)));
     }
-    return {
-        products: paymentMethod.products,
-        cryptoAuthMethod: paymentMethod.cryptoAuthMethod,
-        explicit: true,
-    };
-}, _SubscriptionController_getChainSupportsSponsorship = function _SubscriptionController_getChainSupportsSponsorship(chainId, productType, cryptoAuthMethod) {
-    const cryptoPaymentInfo = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_findCryptoPaymentMethod).call(this, productType, cryptoAuthMethod);
-    if (!cryptoPaymentInfo) {
-        throw new Error('Chains payment info not found');
-    }
-    const chainPaymentInfo = cryptoPaymentInfo.chains?.find((chain) => chain.chainId === chainId);
-    if (!chainPaymentInfo) {
-        throw new Error('Invalid chain id');
-    }
-    return Boolean(chainPaymentInfo.isSponsorshipSupported);
-}, _SubscriptionController_areTrialedProductsEqual = function _SubscriptionController_areTrialedProductsEqual(oldTrialedProducts, newTrialedProducts) {
-    return (oldTrialedProducts.length === newTrialedProducts?.length &&
-        oldTrialedProducts.every((product) => newTrialedProducts?.includes(product)));
-}, _SubscriptionController_areSubscriptionsEqual = function _SubscriptionController_areSubscriptionsEqual(oldSubs, newSubs) {
-    // Check if arrays have different lengths
-    if (oldSubs.length !== newSubs.length) {
-        return false;
-    }
-    // Sort both arrays by id to ensure consistent comparison
-    const sortedOldSubs = [...oldSubs].sort((a, b) => a.id.localeCompare(b.id));
-    const sortedNewSubs = [...newSubs].sort((a, b) => a.id.localeCompare(b.id));
-    // Check if all subscriptions are equal
-    return sortedOldSubs.every((oldSub, index) => {
-        const newSub = sortedNewSubs[index];
-        return __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_isSubscriptionEqual).call(this, oldSub, newSub);
-    });
-}, _SubscriptionController_isSubscriptionEqual = function _SubscriptionController_isSubscriptionEqual(oldSub, newSub) {
-    // not equal if one is undefined and the other is defined
-    if (!oldSub || !newSub) {
-        if (!oldSub && !newSub) {
-            return true;
-        }
-        return false;
-    }
-    return (__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_stringifySubscription).call(this, oldSub) ===
-        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_stringifySubscription).call(this, newSub));
-}, _SubscriptionController_stringifySubscription = function _SubscriptionController_stringifySubscription(subscription) {
-    const subsWithSortedProducts = {
-        ...subscription,
-        // order the products by name
-        products: [...subscription.products].sort((a, b) => a.name.localeCompare(b.name)),
-    };
-    return JSON.stringify(subsWithSortedProducts);
-};
-//# sourceMappingURL=SubscriptionController.mjs.map
+    /**
+     * Compares product entitlement maps without treating object key order as a
+     * change. Insertion-order-sensitive `JSON.stringify` can otherwise treat an
+     * equivalent API payload as different and trigger `performSignOut`.
+     *
+     * @param oldProductEntitlements - Stored product entitlements.
+     * @param newProductEntitlements - Freshly fetched product entitlements.
+     * @returns True if the maps are equal regardless of key order.
+     */
+    #areProductEntitlementsEqual(oldProductEntitlements, newProductEntitlements) {
+        return deepEqual(oldProductEntitlements ?? {}, newProductEntitlements ?? {});
+    }
+    /**
+     * Determines whether two subscription arrays are equal by comparing all properties
+     * of each subscription in the arrays.
+     *
+     * @param oldSubs - The first subscription array to compare.
+     * @param newSubs - The second subscription array to compare.
+     * @returns True if the subscription arrays are equal, false otherwise.
+     */
+    #areSubscriptionsEqual(oldSubs, newSubs) {
+        // Check if arrays have different lengths
+        if (oldSubs.length !== newSubs.length) {
+            return false;
+        }
+        // Sort both arrays by id to ensure consistent comparison
+        const sortedOldSubs = [...oldSubs].sort((a, b) => a.id.localeCompare(b.id));
+        const sortedNewSubs = [...newSubs].sort((a, b) => a.id.localeCompare(b.id));
+        // Check if all subscriptions are equal
+        return sortedOldSubs.every((oldSub, index) => {
+            const newSub = sortedNewSubs[index];
+            return this.#isSubscriptionEqual(oldSub, newSub);
+        });
+    }
+    #isSubscriptionEqual(oldSub, newSub) {
+        // not equal if one is undefined and the other is defined
+        if (!oldSub || !newSub) {
+            if (!oldSub && !newSub) {
+                return true;
+            }
+            return false;
+        }
+        return (this.#stringifySubscription(oldSub) ===
+            this.#stringifySubscription(newSub));
+    }
+    #stringifySubscription(subscription) {
+        const subsWithSortedProducts = {
+            ...subscription,
+            // order the products by name
+            products: [...subscription.products].sort((a, b) => a.name.localeCompare(b.name)),
+        };
+        return JSON.stringify(subsWithSortedProducts);
+    }
+}
+//# sourceMappingURL=SubscriptionController.js.map