@metamask-previews/subscription-controller 6.2.1-preview-b5147cfe0 → 6.2.1-preview-b156b30ed

package/dist/SubscriptionService-structs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionService-structs.d.mts","sourceRoot":"","sources":["../src/SubscriptionService-structs.ts"],"names":[],"mappings":"AA8DA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB7B,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMzC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;EAE1C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;EAGhD,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;EAEhD,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;EAEtC,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;EAG/C,CAAC;AAsCH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AASH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAE9C,CAAC"}

package/dist/SubscriptionService-structs.mjs

@@ -0,0 +1,132 @@
+import { array, boolean, enums, nullable, number, optional, string, type, union } from "@metamask/superstruct";
+import { StrictHexStruct, CaipAccountIdStruct } from "@metamask/utils";
+import { CANCEL_TYPES, CRYPTO_PAYMENT_METHOD_ERRORS, PAYMENT_TYPES, PRODUCT_TYPES, RECURRING_INTERVALS, SUBSCRIPTION_STATUSES } from "./types.mjs";
+const ProductTypeStruct = enums(Object.values(PRODUCT_TYPES));
+const PaymentTypeStruct = enums(Object.values(PAYMENT_TYPES));
+const RecurringIntervalStruct = enums(Object.values(RECURRING_INTERVALS));
+const SubscriptionStatusStruct = enums(Object.values(SUBSCRIPTION_STATUSES));
+const CancelTypeStruct = enums(Object.values(CANCEL_TYPES));
+const CryptoPaymentMethodErrorStruct = enums(Object.values(CRYPTO_PAYMENT_METHOD_ERRORS));
+const ProductStruct = type({
+    name: ProductTypeStruct,
+    currency: enums(['usd']),
+    unitAmount: number(),
+    unitDecimals: number(),
+});
+const SubscriptionCardPaymentMethodStruct = type({
+    type: enums([PAYMENT_TYPES.byCard]),
+    card: type({
+        brand: string(),
+        displayBrand: string(),
+        last4: string(),
+    }),
+});
+const SubscriptionCryptoPaymentMethodStruct = type({
+    type: enums([PAYMENT_TYPES.byCrypto]),
+    crypto: type({
+        payerAddress: StrictHexStruct,
+        chainId: StrictHexStruct,
+        tokenSymbol: string(),
+        error: optional(CryptoPaymentMethodErrorStruct),
+    }),
+});
+const SubscriptionPaymentMethodStruct = union([
+    SubscriptionCardPaymentMethodStruct,
+    SubscriptionCryptoPaymentMethodStruct,
+]);
+export const SubscriptionStruct = type({
+    id: string(),
+    products: array(ProductStruct),
+    currentPeriodStart: string(),
+    currentPeriodEnd: string(),
+    cancelAtPeriodEnd: optional(boolean()),
+    status: SubscriptionStatusStruct,
+    interval: RecurringIntervalStruct,
+    paymentMethod: SubscriptionPaymentMethodStruct,
+    trialPeriodDays: optional(number()),
+    trialStart: optional(string()),
+    trialEnd: optional(string()),
+    endDate: optional(string()),
+    canceledAt: optional(string()),
+    cancelType: CancelTypeStruct,
+    inactiveAt: optional(string()),
+    isEligibleForSupport: boolean(),
+    billingCycles: optional(number()),
+});
+export const GetSubscriptionsResponseStruct = type({
+    customerId: optional(string()),
+    subscriptions: array(SubscriptionStruct),
+    trialedProducts: array(ProductTypeStruct),
+    lastSubscription: optional(SubscriptionStruct),
+    rewardAccountId: optional(CaipAccountIdStruct),
+});
+export const StartSubscriptionResponseStruct = type({
+    checkoutSessionUrl: string(),
+});
+export const StartCryptoSubscriptionResponseStruct = type({
+    subscriptionId: string(),
+    status: SubscriptionStatusStruct,
+});
+export const UpdatePaymentMethodCardResponseStruct = type({
+    redirectUrl: string(),
+});
+export const BillingPortalResponseStruct = type({
+    url: string(),
+});
+export const SubscriptionApiGeneralResponseStruct = type({
+    success: boolean(),
+    message: optional(string()),
+});
+const ProductPriceStruct = type({
+    interval: RecurringIntervalStruct,
+    unitAmount: number(),
+    unitDecimals: number(),
+    currency: enums(['usd']),
+    trialPeriodDays: number(),
+    minBillingCycles: number(),
+    minBillingCyclesForBalance: number(),
+});
+const ProductPricingStruct = type({
+    name: ProductTypeStruct,
+    prices: array(ProductPriceStruct),
+});
+const TokenPaymentInfoStruct = type({
+    symbol: string(),
+    address: StrictHexStruct,
+    decimals: number(),
+    conversionRate: type({
+        usd: string(),
+    }),
+});
+const ChainPaymentInfoStruct = type({
+    chainId: StrictHexStruct,
+    paymentAddress: StrictHexStruct,
+    tokens: array(TokenPaymentInfoStruct),
+    isSponsorshipSupported: optional(boolean()),
+});
+const PricingPaymentMethodStruct = type({
+    type: PaymentTypeStruct,
+    chains: optional(array(ChainPaymentInfoStruct)),
+});
+export const PricingResponseStruct = type({
+    products: array(ProductPricingStruct),
+    paymentMethods: array(PricingPaymentMethodStruct),
+});
+const CohortStruct = type({
+    cohort: string(),
+    eligibilityRate: number(),
+    priority: number(),
+    eligible: boolean(),
+});
+export const SubscriptionEligibilityStruct = type({
+    product: ProductTypeStruct,
+    canSubscribe: optional(boolean()),
+    canViewEntryModal: optional(boolean()),
+    modalType: optional(enums(['A', 'B'])),
+    cohorts: optional(array(CohortStruct)),
+    assignedCohort: optional(nullable(string())),
+    assignedAt: optional(string()),
+    hasAssignedCohortExpired: optional(boolean()),
+});
+export const SubscriptionEligibilityArrayStruct = array(SubscriptionEligibilityStruct);
+//# sourceMappingURL=SubscriptionService-structs.mjs.map

package/dist/SubscriptionService-structs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionService-structs.mjs","sourceRoot":"","sources":["../src/SubscriptionService-structs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  array,\n  boolean,\n  enums,\n  nullable,\n  number,\n  optional,\n  string,\n  type,\n  union,\n} from '@metamask/superstruct';\nimport { StrictHexStruct, CaipAccountIdStruct } from '@metamask/utils';\n\nimport {\n  CANCEL_TYPES,\n  CRYPTO_PAYMENT_METHOD_ERRORS,\n  PAYMENT_TYPES,\n  PRODUCT_TYPES,\n  RECURRING_INTERVALS,\n  SUBSCRIPTION_STATUSES,\n} from './types.js';\n\nconst ProductTypeStruct = enums(Object.values(PRODUCT_TYPES));\nconst PaymentTypeStruct = enums(Object.values(PAYMENT_TYPES));\nconst RecurringIntervalStruct = enums(Object.values(RECURRING_INTERVALS));\nconst SubscriptionStatusStruct = enums(Object.values(SUBSCRIPTION_STATUSES));\nconst CancelTypeStruct = enums(Object.values(CANCEL_TYPES));\nconst CryptoPaymentMethodErrorStruct = enums(\n  Object.values(CRYPTO_PAYMENT_METHOD_ERRORS),\n);\n\nconst ProductStruct = type({\n  name: ProductTypeStruct,\n  currency: enums(['usd']),\n  unitAmount: number(),\n  unitDecimals: number(),\n});\n\nconst SubscriptionCardPaymentMethodStruct = type({\n  type: enums([PAYMENT_TYPES.byCard]),\n  card: type({\n    brand: string(),\n    displayBrand: string(),\n    last4: string(),\n  }),\n});\n\nconst SubscriptionCryptoPaymentMethodStruct = type({\n  type: enums([PAYMENT_TYPES.byCrypto]),\n  crypto: type({\n    payerAddress: StrictHexStruct,\n    chainId: StrictHexStruct,\n    tokenSymbol: string(),\n    error: optional(CryptoPaymentMethodErrorStruct),\n  }),\n});\n\nconst SubscriptionPaymentMethodStruct = union([\n  SubscriptionCardPaymentMethodStruct,\n  SubscriptionCryptoPaymentMethodStruct,\n]);\n\nexport const SubscriptionStruct = type({\n  id: string(),\n  products: array(ProductStruct),\n  currentPeriodStart: string(),\n  currentPeriodEnd: string(),\n  cancelAtPeriodEnd: optional(boolean()),\n  status: SubscriptionStatusStruct,\n  interval: RecurringIntervalStruct,\n  paymentMethod: SubscriptionPaymentMethodStruct,\n  trialPeriodDays: optional(number()),\n  trialStart: optional(string()),\n  trialEnd: optional(string()),\n  endDate: optional(string()),\n  canceledAt: optional(string()),\n  cancelType: CancelTypeStruct,\n  inactiveAt: optional(string()),\n  isEligibleForSupport: boolean(),\n  billingCycles: optional(number()),\n});\n\nexport const GetSubscriptionsResponseStruct = type({\n  customerId: optional(string()),\n  subscriptions: array(SubscriptionStruct),\n  trialedProducts: array(ProductTypeStruct),\n  lastSubscription: optional(SubscriptionStruct),\n  rewardAccountId: optional(CaipAccountIdStruct),\n});\n\nexport const StartSubscriptionResponseStruct = type({\n  checkoutSessionUrl: string(),\n});\n\nexport const StartCryptoSubscriptionResponseStruct = type({\n  subscriptionId: string(),\n  status: SubscriptionStatusStruct,\n});\n\nexport const UpdatePaymentMethodCardResponseStruct = type({\n  redirectUrl: string(),\n});\n\nexport const BillingPortalResponseStruct = type({\n  url: string(),\n});\n\nexport const SubscriptionApiGeneralResponseStruct = type({\n  success: boolean(),\n  message: optional(string()),\n});\n\nconst ProductPriceStruct = type({\n  interval: RecurringIntervalStruct,\n  unitAmount: number(),\n  unitDecimals: number(),\n  currency: enums(['usd']),\n  trialPeriodDays: number(),\n  minBillingCycles: number(),\n  minBillingCyclesForBalance: number(),\n});\n\nconst ProductPricingStruct = type({\n  name: ProductTypeStruct,\n  prices: array(ProductPriceStruct),\n});\n\nconst TokenPaymentInfoStruct = type({\n  symbol: string(),\n  address: StrictHexStruct,\n  decimals: number(),\n  conversionRate: type({\n    usd: string(),\n  }),\n});\n\nconst ChainPaymentInfoStruct = type({\n  chainId: StrictHexStruct,\n  paymentAddress: StrictHexStruct,\n  tokens: array(TokenPaymentInfoStruct),\n  isSponsorshipSupported: optional(boolean()),\n});\n\nconst PricingPaymentMethodStruct = type({\n  type: PaymentTypeStruct,\n  chains: optional(array(ChainPaymentInfoStruct)),\n});\n\nexport const PricingResponseStruct = type({\n  products: array(ProductPricingStruct),\n  paymentMethods: array(PricingPaymentMethodStruct),\n});\n\nconst CohortStruct = type({\n  cohort: string(),\n  eligibilityRate: number(),\n  priority: number(),\n  eligible: boolean(),\n});\n\nexport const SubscriptionEligibilityStruct = type({\n  product: ProductTypeStruct,\n  canSubscribe: optional(boolean()),\n  canViewEntryModal: optional(boolean()),\n  modalType: optional(enums(['A', 'B'])),\n  cohorts: optional(array(CohortStruct)),\n  assignedCohort: optional(nullable(string())),\n  assignedAt: optional(string()),\n  hasAssignedCohortExpired: optional(boolean()),\n});\n\nexport const SubscriptionEligibilityArrayStruct = array(\n  SubscriptionEligibilityStruct,\n);\n"]}

package/dist/SubscriptionService.cjs

@@ -10,36 +10,103 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SubscriptionService_instances, _SubscriptionService_env, _SubscriptionService_fetch, _SubscriptionService_captureException, _SubscriptionService_makeRequest, _SubscriptionService_getAuthorizationHeader, _SubscriptionService_getSubscriptionApiUrl;
+var _SubscriptionService_instances, _SubscriptionService_env, _SubscriptionService_fetch, _SubscriptionService_captureException, _SubscriptionService_fetchJson, _SubscriptionService_getAuthenticatedContext, _SubscriptionService_headersForToken, _SubscriptionService_getSubscriptionApiUrl;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscriptionService = exports.SUBSCRIPTION_URL = void 0;
+exports.SubscriptionService = exports.SUBSCRIPTION_URL = exports.serviceName = void 0;
+const base_data_service_1 = require("@metamask/base-data-service");
+const controller_utils_1 = require("@metamask/controller-utils");
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
 const constants_js_1 = require("./constants.cjs");
 const errors_js_1 = require("./errors.cjs");
 const logger_js_1 = require("./logger.cjs");
+const SubscriptionService_structs_js_1 = require("./SubscriptionService-structs.cjs");
+exports.serviceName = 'SubscriptionService';
 const SUBSCRIPTION_URL = (env, path) => `${(0, constants_js_1.getEnvUrls)(env).subscriptionApiUrl}/v1/${path}`;
 exports.SUBSCRIPTION_URL = SUBSCRIPTION_URL;
+const MESSENGER_EXPOSED_METHODS = [
+    'getSubscriptions',
+    'cancelSubscription',
+    'unCancelSubscription',
+    'startSubscriptionWithCard',
+    'startSubscriptionWithCrypto',
+    'updatePaymentMethodCard',
+    'updatePaymentMethodCrypto',
+    'getSubscriptionsEligibilities',
+    'submitUserEvent',
+    'assignUserToCohort',
+    'submitSponsorshipIntents',
+    'linkRewards',
+    'getPricing',
+    'getBillingPortalUrl',
+];
 const log = (0, logger_js_1.createModuleLogger)(logger_js_1.projectLogger, 'SubscriptionService');
-class SubscriptionService {
-    constructor(config) {
+function isRetryableError(error) {
+    if (error instanceof controller_utils_1.HttpError) {
+        if (error.httpStatus === 429) {
+            return true;
+        }
+        return error.httpStatus < 400 || error.httpStatus >= 500;
+    }
+    return true;
+}
+const DEFAULT_POLICY_OPTIONS = {
+    retryFilterPolicy: (0, controller_utils_1.handleWhen)(isRetryableError),
+};
+/**
+ * Data service for the Subscription API.
+ *
+ * All requests are authenticated via JWT Bearer tokens obtained from the
+ * `AuthenticationController:getBearerToken` messenger action.
+ */
+class SubscriptionService extends base_data_service_1.BaseDataService {
+    constructor({ messenger, fetchFunction, env = constants_js_1.Env.PRD, captureException, queryClientConfig = {}, policyOptions = {}, }) {
+        super({
+            name: exports.serviceName,
+            messenger,
+            queryClientConfig,
+            policyOptions: { ...DEFAULT_POLICY_OPTIONS, ...policyOptions },
+        });
         _SubscriptionService_instances.add(this);
         _SubscriptionService_env.set(this, void 0);
         _SubscriptionService_fetch.set(this, void 0);
         _SubscriptionService_captureException.set(this, void 0);
-        __classPrivateFieldSet(this, _SubscriptionService_env, config.env, "f");
-        this.authUtils = config.auth;
-        __classPrivateFieldSet(this, _SubscriptionService_fetch, config.fetchFunction, "f");
-        __classPrivateFieldSet(this, _SubscriptionService_captureException, config.captureException, "f");
+        __classPrivateFieldSet(this, _SubscriptionService_env, env, "f");
+        __classPrivateFieldSet(this, _SubscriptionService_fetch, fetchFunction, "f");
+        __classPrivateFieldSet(this, _SubscriptionService_captureException, captureException, "f");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
     }
+    /**
+     * Fetches the user's subscriptions.
+     *
+     * @returns The subscriptions response.
+     */
     async getSubscriptions() {
-        const path = 'subscriptions';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'getSubscriptions',
+            requestParams: null,
+            path: 'subscriptions',
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToGetSubscriptions,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.GetSubscriptionsResponseStruct);
     }
+    /**
+     * Cancels a subscription.
+     *
+     * @param params - The cancel subscription request.
+     * @returns The updated subscription.
+     */
     async cancelSubscription(params) {
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
         const path = `subscriptions/${params.subscriptionId}/cancel`;
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'cancelSubscription',
+            requestParams: params,
             path,
             method: 'POST',
             body: {
@@ -47,40 +114,87 @@ class SubscriptionService {
             },
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToCancelSubscription,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.SubscriptionStruct);
     }
+    /**
+     * Reverses a pending subscription cancellation.
+     *
+     * @param params - The uncancel subscription request.
+     * @param params.subscriptionId - The subscription ID to uncancel.
+     * @returns The updated subscription.
+     */
     async unCancelSubscription(params) {
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
         const path = `subscriptions/${params.subscriptionId}/uncancel`;
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'unCancelSubscription',
+            requestParams: params,
             path,
             method: 'POST',
             body: {},
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToUncancelSubscription,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.SubscriptionStruct);
     }
+    /**
+     * Starts a subscription with a card payment method.
+     *
+     * @param request - The start subscription request.
+     * @returns The checkout session response.
+     */
     async startSubscriptionWithCard(request) {
         if (request.products.length === 0) {
             throw new errors_js_1.SubscriptionServiceError(constants_js_1.SubscriptionControllerErrorMessage.SubscriptionProductsEmpty);
         }
-        const path = 'subscriptions/card';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'startSubscriptionWithCard',
+            requestParams: request,
+            path: 'subscriptions/card',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToStartSubscriptionWithCard,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.StartSubscriptionResponseStruct);
     }
+    /**
+     * Starts a subscription with a crypto payment method.
+     *
+     * @param request - The start crypto subscription request.
+     * @returns The created subscription response.
+     */
     async startSubscriptionWithCrypto(request) {
-        const path = 'subscriptions/crypto';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'startSubscriptionWithCrypto',
+            requestParams: request,
+            path: 'subscriptions/crypto',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToStartSubscriptionWithCrypto,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.StartCryptoSubscriptionResponseStruct);
     }
+    /**
+     * Updates a subscription's card payment method.
+     *
+     * @param request - The update payment method request.
+     * @returns The redirect URL response.
+     */
     async updatePaymentMethodCard(request) {
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
         const path = `subscriptions/${request.subscriptionId}/payment-method/card`;
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'updatePaymentMethodCard',
+            requestParams: request,
             path,
             method: 'PATCH',
             body: {
@@ -89,10 +203,21 @@ class SubscriptionService {
             },
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToUpdatePaymentMethodCard,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.UpdatePaymentMethodCardResponseStruct);
     }
+    /**
+     * Updates a subscription's crypto payment method.
+     *
+     * @param request - The update payment method request.
+     */
     async updatePaymentMethodCrypto(request) {
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
         const path = `subscriptions/${request.subscriptionId}/payment-method/crypto`;
-        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
+        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'updatePaymentMethodCrypto',
+            requestParams: request,
             path,
             method: 'PATCH',
             body: {
@@ -109,23 +234,28 @@ class SubscriptionService {
      * @returns The eligibility for a shield subscription
      */
     async getSubscriptionsEligibilities(request) {
-        const path = 'subscriptions/eligibility';
-        let query;
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        let queryParams;
         if (request?.balanceCategory !== undefined) {
-            query = { balanceCategory: request.balanceCategory };
+            queryParams = { balanceCategory: request.balanceCategory };
         }
-        const results = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
-            queryParams: query,
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'getSubscriptionsEligibilities',
+            requestParams: request ?? null,
+            path: 'subscriptions/eligibility',
+            queryParams,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToGetSubscriptionsEligibilities,
         });
+        const results = (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.SubscriptionEligibilityArrayStruct);
         return results.map((result) => ({
             ...result,
-            canSubscribe: result.canSubscribe || false,
-            canViewEntryModal: result.canViewEntryModal || false,
-            cohorts: result.cohorts || [],
+            canSubscribe: result.canSubscribe ?? false,
+            canViewEntryModal: result.canViewEntryModal ?? false,
+            cohorts: result.cohorts ?? [],
             assignedCohort: result.assignedCohort ?? null,
-            hasAssignedCohortExpired: result.hasAssignedCohortExpired || false,
+            hasAssignedCohortExpired: result.hasAssignedCohortExpired ?? false,
         }));
     }
     /**
@@ -135,9 +265,13 @@ class SubscriptionService {
      * @example { event: SubscriptionUserEvent.ShieldEntryModalViewed, cohort: 'post_tx' }
      */
     async submitUserEvent(request) {
-        const path = 'user-events';
-        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'submitUserEvent',
+            requestParams: request,
+            path: 'user-events',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToSubmitUserEvent,
@@ -150,9 +284,13 @@ class SubscriptionService {
      * @example { cohort: 'post_tx' }
      */
     async assignUserToCohort(request) {
-        const path = 'cohorts/assign';
-        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'assignUserToCohort',
+            requestParams: request,
+            path: 'cohorts/assign',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToAssignUserToCohort,
@@ -168,9 +306,13 @@ class SubscriptionService {
      * @example { address: '0x1234567890123456789012345678901234567890', products: [ProductType.Shield] }
      */
     async submitSponsorshipIntents(request) {
-        const path = 'transaction-sponsorship/intents';
-        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'submitSponsorshipIntents',
+            requestParams: request,
+            path: 'transaction-sponsorship/intents',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToSubmitSponsorshipIntents,
@@ -184,81 +326,105 @@ class SubscriptionService {
      * @returns The response from the API.
      */
     async linkRewards(request) {
-        const path = 'rewards/link';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'linkRewards',
+            requestParams: request,
+            path: 'rewards/link',
             method: 'POST',
             body: request,
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToLinkRewards,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.SubscriptionApiGeneralResponseStruct);
     }
+    /**
+     * Fetches subscription pricing information.
+     *
+     * @returns The pricing response.
+     */
     async getPricing() {
-        const path = 'pricing';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'getPricing',
+            requestParams: null,
+            path: 'pricing',
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToGetPricing,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.PricingResponseStruct);
     }
+    /**
+     * Fetches the billing portal URL.
+     *
+     * @returns The billing portal response.
+     */
     async getBillingPortalUrl() {
-        const path = 'billing-portal';
-        return await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_makeRequest).call(this, {
-            path,
+        const { profileKey, bearerToken } = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthenticatedContext).call(this);
+        const jsonResponse = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_fetchJson).call(this, {
+            profileKey,
+            bearerToken,
+            methodName: 'getBillingPortalUrl',
+            requestParams: null,
+            path: 'billing-portal',
             errorMessage: constants_js_1.SubscriptionServiceErrorMessage.FailedToGetBillingPortalUrl,
         });
+        return (0, superstruct_1.create)(jsonResponse, SubscriptionService_structs_js_1.BillingPortalResponseStruct);
     }
 }
 exports.SubscriptionService = SubscriptionService;
-_SubscriptionService_env = new WeakMap(), _SubscriptionService_fetch = new WeakMap(), _SubscriptionService_captureException = new WeakMap(), _SubscriptionService_instances = new WeakSet(), _SubscriptionService_makeRequest = 
-/**
- * Makes a request to the Subscription Service backend.
- *
- * @param params - The request object containing the path, method, body, query parameters, and error message.
- * @param params.path - The path of the request.
- * @param params.method - The method of the request.
- * @param params.body - The body of the request.
- * @param params.queryParams - The query parameters of the request.
- * @param params.errorMessage - The error message to throw if the request fails.
- * @returns The result of the request.
- */
-async function _SubscriptionService_makeRequest({ path, method = 'GET', body, queryParams, errorMessage, }) {
+_SubscriptionService_env = new WeakMap(), _SubscriptionService_fetch = new WeakMap(), _SubscriptionService_captureException = new WeakMap(), _SubscriptionService_instances = new WeakSet(), _SubscriptionService_fetchJson = async function _SubscriptionService_fetchJson({ profileKey, bearerToken, methodName, requestParams, path, method = 'GET', body, queryParams, errorMessage, }) {
     const url = __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getSubscriptionApiUrl).call(this, path);
-    const headers = await __classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_getAuthorizationHeader).call(this);
+    if (queryParams) {
+        Object.entries(queryParams).forEach(([key, value]) => {
+            url.searchParams.append(key, value);
+        });
+    }
     try {
-        if (queryParams) {
-            Object.entries(queryParams).forEach(([key, value]) => {
-                url.searchParams.append(key, value);
-            });
-        }
-        const response = await __classPrivateFieldGet(this, _SubscriptionService_fetch, "f").call(this, url.toString(), {
-            method,
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
+        return await this.fetchQuery({
+            queryKey: [
+                `${this.name}:${methodName}`,
+                profileKey,
+                requestParams,
+            ],
+            staleTime: 0,
+            cacheTime: 0,
+            queryFn: async () => {
+                const response = await __classPrivateFieldGet(this, _SubscriptionService_fetch, "f").call(this, url.toString(), {
+                    method,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...__classPrivateFieldGet(this, _SubscriptionService_instances, "m", _SubscriptionService_headersForToken).call(this, bearerToken),
+                    },
+                    body: body ? JSON.stringify(body) : undefined,
+                });
+                if (!response.ok) {
+                    const apiError = await (0, errors_js_1.getSubscriptionErrorFromResponse)(response);
+                    throw new controller_utils_1.HttpError(response.status, apiError.message);
+                }
+                return response.json();
             },
-            body: body ? JSON.stringify(body) : undefined,
         });
-        if (!response.ok) {
-            const error = await (0, errors_js_1.getSubscriptionErrorFromResponse)(response);
-            throw error;
-        }
-        const data = await response.json();
-        return data;
     }
     catch (error) {
         log(errorMessage, error);
         const errorMessageWithUrl = `${errorMessage} (url: ${url.toString()})`;
         const errorToCapture = error instanceof Error ? error : new Error(errorMessage);
         __classPrivateFieldGet(this, _SubscriptionService_captureException, "f")?.call(this, (0, errors_js_1.createSentryError)(errorMessageWithUrl, errorToCapture));
+        if (error instanceof errors_js_1.SubscriptionServiceError) {
+            throw error;
+        }
         throw new errors_js_1.SubscriptionServiceError(`Failed to make request. ${errorMessageWithUrl}`, {
             cause: errorToCapture,
         });
     }
-}, _SubscriptionService_getAuthorizationHeader = 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-async function _SubscriptionService_getAuthorizationHeader() {
+}, _SubscriptionService_getAuthenticatedContext = async function _SubscriptionService_getAuthenticatedContext() {
     try {
-        const accessToken = await this.authUtils.getAccessToken();
-        return { Authorization: `Bearer ${accessToken}` };
+        const bearerToken = await this.messenger.call('AuthenticationController:getBearerToken');
+        const profileKey = (0, utils_1.bytesToHex)(await (0, utils_1.sha256)((0, utils_1.stringToBytes)(bearerToken)));
+        return { profileKey, bearerToken };
     }
     catch (error) {
         const errorMessage = error instanceof Error
@@ -269,10 +435,11 @@ async function _SubscriptionService_getAuthorizationHeader() {
             cause: error instanceof Error ? error : new Error(errorMessage),
         });
     }
+}, _SubscriptionService_headersForToken = function _SubscriptionService_headersForToken(bearerToken) {
+    return { Authorization: `Bearer ${bearerToken}` };
 }, _SubscriptionService_getSubscriptionApiUrl = function _SubscriptionService_getSubscriptionApiUrl(path) {
     try {
-        const url = new URL((0, exports.SUBSCRIPTION_URL)(__classPrivateFieldGet(this, _SubscriptionService_env, "f"), path));
-        return url;
+        return new URL((0, exports.SUBSCRIPTION_URL)(__classPrivateFieldGet(this, _SubscriptionService_env, "f"), path));
     }
     catch (error) {
         const errorMessage = error instanceof Error