@metamask-previews/subscription-controller 8.0.1-preview-3866c0ff1 → 8.0.1-preview-e3275932a

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

@@ -1,8 +1,14 @@
-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.js';
-import { CRYPTO_AUTH_METHODS, PAYMENT_TYPES, PRODUCT_TYPES, SUBSCRIPTION_STATUSES, } from './types.js';
+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";
 /**
  * Get the default state for the Subscription Controller.
  *
@@ -110,6 +116,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             },
             messenger,
         });
+        _SubscriptionController_instances.add(this);
         this.setIntervalLength(pollingInterval);
         this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
     }
@@ -133,11 +140,11 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         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 = this.#areSubscriptionsEqual(currentSubscriptions, newSubscriptions);
+        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 = this.#areTrialedProductsEqual(currentTrialedProducts, newTrialedProducts);
+        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 = this.#isSubscriptionEqual(currentLastSubscription, newLastSubscription);
+        const isLastSubscriptionEqual = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_isSubscriptionEqual).call(this, currentLastSubscription, newLastSubscription);
         const areCustomerIdsEqual = currentCustomerId === newCustomerId;
         const areRewardAccountIdsEqual = currentRewardAccountId === newRewardAccountId;
         // only update the state if the subscriptions or trialed products are different
@@ -178,7 +185,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         return await this.messenger.call('SubscriptionService:getSubscriptionsEligibilities', request);
     }
     async cancelSubscription(request) {
-        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { 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
@@ -188,7 +195,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         this.triggerAccessTokenRefresh();
     }
     async unCancelSubscription(request) {
-        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
         const uncancelledSubscription = await this.messenger.call('SubscriptionService:unCancelSubscription', {
             subscriptionId: request.subscriptionId,
         });
@@ -212,10 +219,10 @@ export class SubscriptionController extends StaticIntervalPollingController() {
     async startSubscriptionWithCard(request) {
         // get the latest subscriptions state before computing trial eligibility
         await this.getSubscriptions();
-        this.#assertIsUserNotSubscribed({ products: request.products });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
         const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCard', {
             ...request,
-            isTrialRequested: this.#getIsTrialRequested(request.products, request.recurringInterval),
+            isTrialRequested: __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, 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;
@@ -239,10 +246,10 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         }
         // get the latest subscriptions state before computing trial eligibility
         await this.getSubscriptions();
-        this.#assertIsUserNotSubscribed({ products: request.products });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
         const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCrypto', {
             ...request,
-            isTrialRequested: this.#getIsTrialRequested(request.products, request.recurringInterval),
+            isTrialRequested: __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, request.products, request.recurringInterval),
         });
         // Crypto start creates the subscription immediately (unlike card checkout).
         await this.getSubscriptions();
@@ -290,13 +297,13 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             throw new Error('Last selected payment method not found');
         }
         const lastSelectedPaymentMethodForProduct = lastSelectedPaymentMethod[productType];
-        this.#assertIsPaymentMethodCrypto(lastSelectedPaymentMethodForProduct);
-        const productPrice = this.#getProductPriceByProductAndPlan(productType, lastSelectedPaymentMethodForProduct.plan);
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsPaymentMethodCrypto).call(this, lastSelectedPaymentMethodForProduct);
+        const productPrice = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getProductPriceByProductAndPlan).call(this, productType, lastSelectedPaymentMethodForProduct.plan);
         // get the latest subscriptions state before computing trial eligibility
         await this.getSubscriptions();
-        const isTrialRequested = this.#getIsTrialRequested([productType], lastSelectedPaymentMethodForProduct.plan);
+        const isTrialRequested = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsTrialRequested).call(this, [productType], lastSelectedPaymentMethodForProduct.plan);
         const currentSubscription = this.getSubscriptionByProduct(productType);
-        this.#assertValidSubscriptionStateForCryptoApproval({
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertValidSubscriptionStateForCryptoApproval).call(this, {
             productType,
         });
         // if subscription exists, this transaction is for changing payment method
@@ -356,7 +363,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (!price) {
             throw new Error('Price not found');
         }
-        const chainsPaymentInfo = this.#findCryptoPaymentMethod(request.productType, CRYPTO_AUTH_METHODS.ERC20_APPROVAL);
+        const chainsPaymentInfo = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_findCryptoPaymentMethod).call(this, request.productType, CRYPTO_AUTH_METHODS.ERC20_APPROVAL);
         if (!chainsPaymentInfo) {
             throw new Error('Chains payment info not found');
         }
@@ -454,17 +461,17 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (request.products.length === 0) {
             throw new Error(SubscriptionControllerErrorMessage.SubscriptionProductsEmpty);
         }
-        this.#assertIsUserNotSubscribed({ products: request.products });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
         const selectedPaymentMethod = this.state.lastSelectedPaymentMethod?.[request.products[0]];
-        this.#assertIsPaymentMethodCrypto(selectedPaymentMethod);
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsPaymentMethodCrypto).call(this, selectedPaymentMethod);
         const cryptoAuthMethod = selectedPaymentMethod.cryptoAuthMethod ??
             CRYPTO_AUTH_METHODS.ERC20_APPROVAL;
-        const isEligibleForTrialedSponsorship = this.#getIsEligibleForTrialedSponsorship(request.chainId, request.products, cryptoAuthMethod);
+        const isEligibleForTrialedSponsorship = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getIsEligibleForTrialedSponsorship).call(this, request.chainId, request.products, cryptoAuthMethod);
         if (!isEligibleForTrialedSponsorship) {
             return false;
         }
         const { paymentTokenSymbol, plan } = selectedPaymentMethod;
-        const productPrice = this.#getProductPriceByProductAndPlan(
+        const productPrice = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getProductPriceByProductAndPlan).call(this, 
         // we only support one product at a time for now
         request.products[0], plan);
         const billingCycles = productPrice.minBillingCycles;
@@ -505,7 +512,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
      */
     async linkRewards(request) {
         // assert that the user is subscribed to the subscription
-        this.#assertIsUserSubscribed({ subscriptionId: request.subscriptionId });
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
         // link rewards to the subscription
         const response = await this.messenger.call('SubscriptionService:linkRewards', {
             rewardAccountId: request.rewardAccountId,
@@ -517,35 +524,6 @@ export class SubscriptionController extends StaticIntervalPollingController() {
     async _executePoll() {
         await this.getSubscriptions();
     }
-    /**
-     * 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
      *
@@ -559,7 +537,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
             throw new Error('Conversion rate not found');
         }
         // price of the product
-        const priceAmount = new BigNumber(this.#getSubscriptionPriceAmount(price));
+        const priceAmount = new BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionPriceAmount).call(this, price));
         const tokenDecimal = new BigNumber(10).pow(tokenPaymentInfo.decimals);
         const tokenAmount = priceAmount
             .multipliedBy(tokenDecimal)
@@ -578,7 +556,7 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         if (!conversionRate) {
             throw new Error('Conversion rate not found');
         }
-        const balanceAmount = new BigNumber(this.#getSubscriptionBalanceAmount(price));
+        const balanceAmount = new BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionBalanceAmount).call(this, price));
         const tokenDecimal = new BigNumber(10).pow(tokenPaymentInfo.decimals);
         const tokenAmount = balanceAmount
             .multipliedBy(tokenDecimal)
@@ -603,219 +581,159 @@ export class SubscriptionController extends StaticIntervalPollingController() {
         // will be fetched.
         this.messenger.call('AuthenticationController:performSignOut');
     }
-    #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;
-    }
-    #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);
-        }
-    }
-    #assertIsUserSubscribed(request) {
-        if (!this.state.subscriptions.find((subscription) => subscription.id === request.subscriptionId)) {
-            throw new Error(SubscriptionControllerErrorMessage.UserNotSubscribed);
+}
+_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;
         }
-    }
-    /**
-     * 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);
+        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,
+            });
         }
     }
-    /**
-     * 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;
+    if (matches.length === 0) {
+        return undefined;
     }
-    /**
-     * 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;
+    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');
     }
-    /**
-     * 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 candidates[0].method;
+}, _SubscriptionController_resolveCryptoPaymentMethodDefaults = function _SubscriptionController_resolveCryptoPaymentMethodDefaults(paymentMethod) {
+    const productsPresent = paymentMethod.products !== undefined;
+    const authPresent = paymentMethod.cryptoAuthMethod !== undefined;
+    if (!productsPresent && !authPresent) {
         return {
-            products: paymentMethod.products,
-            cryptoAuthMethod: paymentMethod.cryptoAuthMethod,
-            explicit: true,
+            products: [PRODUCT_TYPES.SHIELD],
+            cryptoAuthMethod: CRYPTO_AUTH_METHODS.ERC20_APPROVAL,
+            explicit: false,
         };
     }
-    /**
-     * 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)));
-    }
-    /**
-     * 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);
-        });
+    if (!paymentMethod.products?.length || !paymentMethod.cryptoAuthMethod) {
+        return undefined;
     }
-    #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
+    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