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

package/dist/SubscriptionController.cjs

@@ -0,0 +1,744 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionController = exports.getDefaultSubscriptionControllerState = void 0;
+const polling_controller_1 = require("@metamask/polling-controller");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+const bignumber_js_1 = require("bignumber.js");
+const constants_js_1 = require("./constants.cjs");
+const types_js_1 = require("./types.cjs");
+/**
+ * Get the default state for the Subscription Controller.
+ *
+ * @returns The default state for the Subscription Controller.
+ */
+function getDefaultSubscriptionControllerState() {
+    return {
+        subscriptions: [],
+        trialedProducts: [],
+    };
+}
+exports.getDefaultSubscriptionControllerState = getDefaultSubscriptionControllerState;
+/**
+ * Seedless Onboarding Controller State Metadata.
+ *
+ * This allows us to choose if fields of the state should be persisted or not
+ * using the `persist` flag; and if they can be sent to Sentry or not, using
+ * the `anonymous` flag.
+ */
+const subscriptionControllerMetadata = {
+    subscriptions: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastSubscription: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    customerId: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    rewardAccountId: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    trialedProducts: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    pricing: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    lastSelectedPaymentMethod: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'getPricing',
+    'getSubscriptions',
+    'getSubscriptionByProduct',
+    'getSubscriptionsEligibilities',
+    'cancelSubscription',
+    'unCancelSubscription',
+    'startSubscriptionWithCard',
+    'startSubscriptionWithCrypto',
+    'stopAllPolling',
+    'submitSubscriptionCryptoApproval',
+    'getCryptoApproveTransactionParams',
+    'updatePaymentMethod',
+    'getBillingPortalUrl',
+    'cacheLastSelectedPaymentMethod',
+    'clearLastSelectedPaymentMethod',
+    'submitSponsorshipIntents',
+    'submitUserEvent',
+    'assignUserToCohort',
+    'linkRewards',
+    'getTokenApproveAmount',
+    'getTokenMinimumBalanceAmount',
+    'clearState',
+    'triggerAccessTokenRefresh',
+];
+class SubscriptionController extends (0, polling_controller_1.StaticIntervalPollingController)() {
+    /**
+     * Creates a new SubscriptionController instance.
+     *
+     * @param options - The options for the SubscriptionController.
+     * @param options.messenger - A restricted messenger.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.pollingInterval - The polling interval to use for the subscription controller.
+     */
+    constructor(options) {
+        const { messenger, state, pollingInterval = constants_js_1.DEFAULT_POLLING_INTERVAL, } = options;
+        super({
+            name: constants_js_1.controllerName,
+            metadata: subscriptionControllerMetadata,
+            state: {
+                ...getDefaultSubscriptionControllerState(),
+                ...state,
+            },
+            messenger,
+        });
+        _SubscriptionController_instances.add(this);
+        this.setIntervalLength(pollingInterval);
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    /**
+     * Gets the pricing information from the subscription service.
+     *
+     * @returns The pricing information.
+     */
+    async getPricing() {
+        const pricing = await this.messenger.call('SubscriptionService:getPricing');
+        this.update((state) => {
+            state.pricing = pricing;
+        });
+        return pricing;
+    }
+    async getSubscriptions() {
+        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 areCustomerIdsEqual = currentCustomerId === newCustomerId;
+        const areRewardAccountIdsEqual = currentRewardAccountId === newRewardAccountId;
+        // only update the state if the subscriptions or trialed products are different
+        // this prevents unnecessary state updates events, easier for the clients to handle
+        if (!areSubscriptionsEqual ||
+            !isLastSubscriptionEqual ||
+            !areTrialedProductsEqual ||
+            !areCustomerIdsEqual ||
+            !areRewardAccountIdsEqual) {
+            this.update((state) => {
+                state.subscriptions = newSubscriptions;
+                state.customerId = newCustomerId;
+                state.trialedProducts = newTrialedProducts;
+                state.lastSubscription = newLastSubscription;
+                state.rewardAccountId = newRewardAccountId;
+            });
+            // trigger access token refresh to ensure the user has the latest access token if subscription state change
+            this.triggerAccessTokenRefresh();
+        }
+        return newSubscriptions;
+    }
+    /**
+     * Get the subscription by product.
+     *
+     * @param productType - The product type.
+     * @returns The subscription.
+     */
+    getSubscriptionByProduct(productType) {
+        return this.state.subscriptions.find((subscription) => subscription.products.some((product) => product.name === productType));
+    }
+    /**
+     * Get the subscriptions eligibilities.
+     *
+     * @param request - Optional request object containing user balance to check cohort eligibility.
+     * @returns The subscriptions eligibilities.
+     */
+    async getSubscriptionsEligibilities(request) {
+        return await this.messenger.call('SubscriptionService:getSubscriptionsEligibilities', request);
+    }
+    async cancelSubscription(request) {
+        __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
+                ? { ...subscription, ...cancelledSubscription }
+                : subscription);
+        });
+        this.triggerAccessTokenRefresh();
+    }
+    async unCancelSubscription(request) {
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserSubscribed).call(this, { subscriptionId: request.subscriptionId });
+        const uncancelledSubscription = await this.messenger.call('SubscriptionService:unCancelSubscription', {
+            subscriptionId: request.subscriptionId,
+        });
+        this.update((state) => {
+            state.subscriptions = state.subscriptions.map((subscription) => subscription.id === request.subscriptionId
+                ? { ...subscription, ...uncancelledSubscription }
+                : subscription);
+        });
+        this.triggerAccessTokenRefresh();
+    }
+    /**
+     * Starts a card-paid subscription checkout session for the requested products
+     * (e.g. Shield or Money Account Plus).
+     *
+     * `isTrialRequested` on the request is ignored and overwritten from pricing
+     * (`trialPeriodDays > 0`) and `trialedProducts`.
+     *
+     * @param request - The start subscription request.
+     * @returns The checkout session response.
+     */
+    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 });
+        const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCard', {
+            ...request,
+            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;
+    }
+    /**
+     * Starts a crypto-paid subscription for the requested products
+     * (e.g. Shield or Money Account Plus). Unlike card checkout, this
+     * creates the subscription immediately, so local state is refreshed
+     * afterwards.
+     *
+     * `isTrialRequested` on the request is ignored and overwritten from pricing
+     * (`trialPeriodDays > 0`) and `trialedProducts`.
+     *
+     * @param request - The start crypto subscription request.
+     * @returns The start crypto subscription response.
+     * @throws If `products` is empty.
+     */
+    async startSubscriptionWithCrypto(request) {
+        if (request.products.length === 0) {
+            throw new Error(constants_js_1.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 });
+        const response = await this.messenger.call('SubscriptionService:startSubscriptionWithCrypto', {
+            ...request,
+            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();
+        return response;
+    }
+    /**
+     * Submits a Shield ERC-20 crypto approval transaction to start or update a
+     * crypto subscription.
+     *
+     * This handler is Shield / `TransactionType.shieldSubscriptionApprove` only.
+     * Delegation-based products (e.g. Money Account) must call
+     * `startSubscriptionWithCrypto` instead.
+     *
+     * @param request - The crypto approval request.
+     * @param request.productType - The subscription product. Typed as
+     * `typeof PRODUCT_TYPES.SHIELD` only at the moment (future might support more
+     * product).
+     * @param request.txMeta - The transaction metadata. Must have type
+     * `TransactionType.shieldSubscriptionApprove`.
+     * @param request.isSponsored - Whether the transaction is sponsored.
+     * @param request.rewardAccountId - The account ID of the reward subscription
+     * to link.
+     * @throws If `productType` is not Shield or `txMeta.type` is not
+     * `shieldSubscriptionApprove`.
+     * @returns void
+     */
+    async submitSubscriptionCryptoApproval(request) {
+        const { productType, txMeta, isSponsored, rewardAccountId } = request;
+        if (
+        // Widen for the runtime guard: JS / unsound callers may still pass a
+        // non-Shield product.
+        productType !== types_js_1.PRODUCT_TYPES.SHIELD ||
+            txMeta.type !== transaction_controller_1.TransactionType.shieldSubscriptionApprove) {
+            throw new Error(constants_js_1.SubscriptionControllerErrorMessage.CryptoApprovalRequiresShieldApprove);
+        }
+        const { chainId, rawTx } = txMeta;
+        if (!chainId || !rawTx) {
+            throw new Error('Chain ID or raw transaction not found');
+        }
+        const { pricing, lastSelectedPaymentMethod } = this.state;
+        if (!pricing) {
+            throw new Error('Subscription pricing not found');
+        }
+        if (!lastSelectedPaymentMethod) {
+            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);
+        // 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);
+        const currentSubscription = this.getSubscriptionByProduct(productType);
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertValidSubscriptionStateForCryptoApproval).call(this, {
+            productType,
+        });
+        // if subscription exists, this transaction is for changing payment method
+        const isChangePaymentMethod = Boolean(currentSubscription);
+        if (isChangePaymentMethod) {
+            await this.updatePaymentMethod({
+                paymentType: types_js_1.PAYMENT_TYPES.byCrypto,
+                subscriptionId: currentSubscription.id,
+                chainId,
+                payerAddress: txMeta.txParams.from,
+                tokenSymbol: lastSelectedPaymentMethodForProduct.paymentTokenSymbol,
+                rawTransaction: rawTx,
+                recurringInterval: productPrice.interval,
+                billingCycles: productPrice.minBillingCycles,
+            });
+        }
+        else {
+            const params = {
+                products: [productType],
+                isTrialRequested,
+                recurringInterval: productPrice.interval,
+                billingCycles: productPrice.minBillingCycles,
+                chainId,
+                payerAddress: txMeta.txParams.from,
+                tokenSymbol: lastSelectedPaymentMethodForProduct.paymentTokenSymbol,
+                rawTransaction: rawTx,
+                cryptoAuthMethod: types_js_1.CRYPTO_AUTH_METHODS.ERC20_APPROVAL,
+                isSponsored,
+                useTestClock: lastSelectedPaymentMethodForProduct.useTestClock,
+                rewardAccountId,
+            };
+            await this.startSubscriptionWithCrypto(params);
+        }
+        // update the subscriptions state after subscription created in server
+        await this.getSubscriptions();
+    }
+    /**
+     * Get transaction params to create crypto approve transaction for subscription payment
+     *
+     * @param request - The request object
+     * @param request.chainId - The chain ID
+     * @param request.tokenAddress - The address of the token
+     * @param request.productType - The product type
+     * @param request.interval - The interval
+     * @returns The crypto approve transaction params
+     */
+    getCryptoApproveTransactionParams(request) {
+        const { pricing } = this.state;
+        if (!pricing) {
+            throw new Error('Subscription pricing not found');
+        }
+        const product = pricing.products.find((productInfo) => productInfo.name === request.productType);
+        if (!product) {
+            throw new Error('Product price not found');
+        }
+        const price = product.prices.find((productPrice) => productPrice.interval === request.interval);
+        if (!price) {
+            throw new Error('Price not found');
+        }
+        const chainsPaymentInfo = __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_findCryptoPaymentMethod).call(this, request.productType, types_js_1.CRYPTO_AUTH_METHODS.ERC20_APPROVAL);
+        if (!chainsPaymentInfo) {
+            throw new Error('Chains payment info not found');
+        }
+        const chainPaymentInfo = chainsPaymentInfo.chains?.find((chain) => chain.chainId === request.chainId);
+        if (!chainPaymentInfo) {
+            throw new Error('Invalid chain id');
+        }
+        const tokenPaymentInfo = chainPaymentInfo.tokens.find((token) => token.address.toLowerCase() ===
+            request.paymentTokenAddress.toLowerCase());
+        if (!tokenPaymentInfo) {
+            throw new Error('Invalid token address');
+        }
+        const tokenApproveAmount = this.getTokenApproveAmount(price, tokenPaymentInfo);
+        return {
+            approveAmount: tokenApproveAmount,
+            paymentAddress: chainPaymentInfo.paymentAddress,
+            paymentTokenAddress: request.paymentTokenAddress,
+            chainId: request.chainId,
+        };
+    }
+    async updatePaymentMethod(opts) {
+        if (opts.paymentType === types_js_1.PAYMENT_TYPES.byCard) {
+            const { paymentType, ...cardRequest } = opts;
+            return await this.messenger.call('SubscriptionService:updatePaymentMethodCard', cardRequest);
+        }
+        else if (opts.paymentType === types_js_1.PAYMENT_TYPES.byCrypto) {
+            const { paymentType, ...cryptoRequest } = opts;
+            await this.messenger.call('SubscriptionService:updatePaymentMethodCrypto', cryptoRequest);
+            return await this.getSubscriptions();
+        }
+        throw new Error('Invalid payment type');
+    }
+    /**
+     * Gets the billing portal URL.
+     *
+     * @returns The billing portal URL
+     */
+    async getBillingPortalUrl() {
+        return await this.messenger.call('SubscriptionService:getBillingPortalUrl');
+    }
+    /**
+     * Cache the last selected payment method for a specific product.
+     *
+     * @param request - The request object.
+     * @param request.product - The product to cache the payment method for.
+     * @param request.paymentMethod - The payment method to cache.
+     * @param request.paymentMethod.type - The type of the payment method.
+     * @param request.paymentMethod.paymentTokenAddress - The payment token address.
+     * @param request.paymentMethod.plan - The plan of the payment method.
+     */
+    cacheLastSelectedPaymentMethod(request) {
+        const { product, paymentMethod } = request;
+        if (paymentMethod.type === types_js_1.PAYMENT_TYPES.byCrypto &&
+            (!paymentMethod.paymentTokenAddress || !paymentMethod.paymentTokenSymbol)) {
+            throw new Error(constants_js_1.SubscriptionControllerErrorMessage.PaymentTokenAddressAndSymbolRequiredForCrypto);
+        }
+        this.update((state) => {
+            state.lastSelectedPaymentMethod = {
+                ...state.lastSelectedPaymentMethod,
+                [product]: paymentMethod,
+            };
+        });
+    }
+    /**
+     * Clear the last selected payment method for a specific product.
+     *
+     * @param product - The product to clear the payment method for.
+     */
+    clearLastSelectedPaymentMethod(product) {
+        this.update((state) => {
+            if (state.lastSelectedPaymentMethod) {
+                const { [product]: _, ...rest } = state.lastSelectedPaymentMethod;
+                state.lastSelectedPaymentMethod =
+                    rest;
+            }
+        });
+    }
+    /**
+     * Submit sponsorship intents to the Subscription Service backend.
+     *
+     * This is intended to be used together with the crypto subscription flow.
+     * When the user has enabled the smart transaction feature, we will sponsor the gas fees for the subscription approval transaction.
+     *
+     * @param request - Request object containing the address and products.
+     * @example {
+     *   address: '0x1234567890123456789012345678901234567890',
+     *   products: [ProductType.Shield],
+     *   recurringInterval: RecurringInterval.Month,
+     *   billingCycles: 1,
+     * }
+     * @returns resolves to true if the sponsorship is supported and intents were submitted successfully, false if the chain does not support sponsorship or the user has already trialed
+     * @throws If the crypto payment method or chain is missing from pricing
+     */
+    async submitSponsorshipIntents(request) {
+        if (request.products.length === 0) {
+            throw new Error(constants_js_1.SubscriptionControllerErrorMessage.SubscriptionProductsEmpty);
+        }
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsUserNotSubscribed).call(this, { products: request.products });
+        const selectedPaymentMethod = this.state.lastSelectedPaymentMethod?.[request.products[0]];
+        __classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_assertIsPaymentMethodCrypto).call(this, selectedPaymentMethod);
+        const cryptoAuthMethod = selectedPaymentMethod.cryptoAuthMethod ??
+            types_js_1.CRYPTO_AUTH_METHODS.ERC20_APPROVAL;
+        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 = __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;
+        await this.messenger.call('SubscriptionService:submitSponsorshipIntents', {
+            ...request,
+            paymentTokenSymbol,
+            billingCycles,
+            recurringInterval: plan,
+        });
+        return true;
+    }
+    /**
+     * Submit a user event from the UI. (e.g. shield modal viewed)
+     *
+     * @param request - Request object containing the event to submit.
+     * @example { event: SubscriptionUserEvent.ShieldEntryModalViewed, cohort: 'post_tx' }
+     */
+    async submitUserEvent(request) {
+        await this.messenger.call('SubscriptionService:submitUserEvent', request);
+    }
+    /**
+     * Assign user to a cohort.
+     *
+     * @param request - Request object containing the cohort to assign the user to.
+     * @example { cohort: 'post_tx' }
+     */
+    async assignUserToCohort(request) {
+        await this.messenger.call('SubscriptionService:assignUserToCohort', request);
+    }
+    /**
+     * Link rewards to a subscription.
+     *
+     * @param request - Request object containing the reward subscription ID.
+     * @param request.subscriptionId - The ID of the subscription to link rewards to.
+     * @param request.rewardAccountId - The account ID of the reward subscription to link to the subscription.
+     * @example { subscriptionId: '1234567890', rewardAccountId: 'eip155:1:0x1234567890123456789012345678901234567890' }
+     * @returns Resolves when the rewards are linked successfully.
+     */
+    async linkRewards(request) {
+        // assert that the user is subscribed to the subscription
+        __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,
+        });
+        if (!response.success) {
+            throw new Error(constants_js_1.SubscriptionControllerErrorMessage.LinkRewardsFailed);
+        }
+    }
+    async _executePoll() {
+        await this.getSubscriptions();
+    }
+    /**
+     * Calculate token approve amount from price info
+     *
+     * @param price - The price info
+     * @param tokenPaymentInfo - The token price info
+     * @returns The token approve amount
+     */
+    getTokenApproveAmount(price, tokenPaymentInfo) {
+        const conversionRate = tokenPaymentInfo.conversionRate?.[price.currency];
+        if (!conversionRate) {
+            throw new Error('Conversion rate not found');
+        }
+        // price of the product
+        const priceAmount = new bignumber_js_1.BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionPriceAmount).call(this, price));
+        const tokenDecimal = new bignumber_js_1.BigNumber(10).pow(tokenPaymentInfo.decimals);
+        const tokenAmount = priceAmount
+            .multipliedBy(tokenDecimal)
+            .div(conversionRate);
+        return tokenAmount.toFixed(0);
+    }
+    /**
+     * Calculate token minimum balance amount from price info
+     *
+     * @param price - The price info
+     * @param tokenPaymentInfo - The token price info
+     * @returns The token balance amount
+     */
+    getTokenMinimumBalanceAmount(price, tokenPaymentInfo) {
+        const conversionRate = tokenPaymentInfo.conversionRate?.[price.currency];
+        if (!conversionRate) {
+            throw new Error('Conversion rate not found');
+        }
+        const balanceAmount = new bignumber_js_1.BigNumber(__classPrivateFieldGet(this, _SubscriptionController_instances, "m", _SubscriptionController_getSubscriptionBalanceAmount).call(this, price));
+        const tokenDecimal = new bignumber_js_1.BigNumber(10).pow(tokenPaymentInfo.decimals);
+        const tokenAmount = balanceAmount
+            .multipliedBy(tokenDecimal)
+            .div(conversionRate);
+        return tokenAmount.toFixed(0);
+    }
+    /**
+     * Clears the subscription state and resets to default values.
+     */
+    clearState() {
+        const defaultState = getDefaultSubscriptionControllerState();
+        this.update(() => {
+            return defaultState;
+        });
+    }
+    /**
+     * Triggers an access token refresh.
+     */
+    triggerAccessTokenRefresh() {
+        // We perform a sign out to clear the access token from the authentication
+        // controller. Next time the access token is requested, a new access token
+        // will be fetched.
+        this.messenger.call('AuthenticationController:performSignOut');
+    }
+}
+exports.SubscriptionController = SubscriptionController;
+_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_js_1.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_js_1.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(constants_js_1.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 ||
+        [
+            types_js_1.SUBSCRIPTION_STATUSES.pastDue,
+            types_js_1.SUBSCRIPTION_STATUSES.unpaid,
+            types_js_1.SUBSCRIPTION_STATUSES.paused,
+            types_js_1.SUBSCRIPTION_STATUSES.provisional,
+            types_js_1.SUBSCRIPTION_STATUSES.active,
+            types_js_1.SUBSCRIPTION_STATUSES.trialing,
+        ].includes(subscription.status);
+    if (!isValid) {
+        throw new Error(constants_js_1.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 &&
+        constants_js_1.ACTIVE_SUBSCRIPTION_STATUSES.includes(subscription.status)) {
+        throw new Error(constants_js_1.SubscriptionControllerErrorMessage.UserAlreadySubscribed);
+    }
+}, _SubscriptionController_assertIsUserSubscribed = function _SubscriptionController_assertIsUserSubscribed(request) {
+    if (!this.state.subscriptions.find((subscription) => subscription.id === request.subscriptionId)) {
+        throw new Error(constants_js_1.SubscriptionControllerErrorMessage.UserNotSubscribed);
+    }
+}, _SubscriptionController_assertIsPaymentMethodCrypto = function _SubscriptionController_assertIsPaymentMethodCrypto(value) {
+    if (value?.type !== types_js_1.PAYMENT_TYPES.byCrypto ||
+        !value.paymentTokenAddress ||
+        !value.paymentTokenSymbol) {
+        throw new Error(constants_js_1.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;
+        }
+        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 !== types_js_1.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,
+            });
+        }
+    }
+    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;
+}, _SubscriptionController_resolveCryptoPaymentMethodDefaults = function _SubscriptionController_resolveCryptoPaymentMethodDefaults(paymentMethod) {
+    const productsPresent = paymentMethod.products !== undefined;
+    const authPresent = paymentMethod.cryptoAuthMethod !== undefined;
+    if (!productsPresent && !authPresent) {
+        return {
+            products: [types_js_1.PRODUCT_TYPES.SHIELD],
+            cryptoAuthMethod: types_js_1.CRYPTO_AUTH_METHODS.ERC20_APPROVAL,
+            explicit: false,
+        };
+    }
+    if (!paymentMethod.products?.length || !paymentMethod.cryptoAuthMethod) {
+        return undefined;
+    }
+    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.cjs.map