@metamask-previews/notification-services-controller 26.0.1-preview-4f4c98e → 26.0.1-preview-eb263b0ee

package/dist/NotificationServicesController/NotificationServicesController.cjs

@@ -0,0 +1,1055 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NotificationServicesController_instances, _NotificationServicesController_keyringController, _NotificationServicesController_auth, _NotificationServicesController_pushNotifications, _NotificationServicesController_accounts, _NotificationServicesController_locale, _NotificationServicesController_featureAnnouncementEnv, _NotificationServicesController_env, _NotificationServicesController_clearLoadingStates, _NotificationServicesController_assertAuthEnabled, _NotificationServicesController_enableAuth, _NotificationServicesController_getBearerToken, _NotificationServicesController_registerWalletActivityAddresses, _NotificationServicesController_setIsUpdatingMetamaskNotifications, _NotificationServicesController_setIsFetchingMetamaskNotifications, _NotificationServicesController_setIsCheckingAccountsPresence, _NotificationServicesController_updateUpdatingAccountsState, _NotificationServicesController_clearUpdatingAccountsState;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationServicesController = exports.DEFAULT_PRICE_ALERT_PREFERENCES = exports.DEFAULT_AGENTIC_CLI_PREFERENCES = exports.DEFAULT_SOCIAL_AI_PREFERENCES = exports.DEFAULT_PERPS_PREFERENCES = exports.defaultState = exports.ACCOUNTS_UPDATE_DEBOUNCE_TIME_MS = void 0;
+const authenticated_user_storage_1 = require("@metamask/authenticated-user-storage");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const utils_1 = require("@metamask/utils");
+const lodash_1 = require("lodash");
+const loglevel_1 = __importDefault(require("loglevel"));
+const notification_schema_js_1 = require("./constants/notification-schema.cjs");
+const process_notifications_js_1 = require("./processors/process-notifications.cjs");
+const api_notifications_js_1 = require("./services/api-notifications.cjs");
+const feature_announcements_js_1 = require("./services/feature-announcements.cjs");
+const perp_notifications_js_1 = require("./services/perp-notifications.cjs");
+// Unique name for the controller
+const controllerName = 'NotificationServicesController';
+exports.ACCOUNTS_UPDATE_DEBOUNCE_TIME_MS = 1000;
+const metadata = {
+    subscriptionAccountsSeen: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    isMetamaskNotificationsFeatureSeen: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isNotificationServicesEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isFeatureAnnouncementsEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    metamaskNotificationsList: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    metamaskNotificationsReadList: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    isUpdatingMetamaskNotifications: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isFetchingMetamaskNotifications: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isUpdatingMetamaskNotificationsAccount: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isCheckingAccountsPresence: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+exports.defaultState = {
+    subscriptionAccountsSeen: [],
+    isMetamaskNotificationsFeatureSeen: false,
+    isNotificationServicesEnabled: false,
+    isFeatureAnnouncementsEnabled: false,
+    metamaskNotificationsList: [],
+    metamaskNotificationsReadList: [],
+    isUpdatingMetamaskNotifications: false,
+    isFetchingMetamaskNotifications: false,
+    isUpdatingMetamaskNotificationsAccount: [],
+    isCheckingAccountsPresence: false,
+};
+const locallyPersistedNotificationTypes = new Set([
+    notification_schema_js_1.TRIGGER_TYPES.SNAP,
+]);
+/**
+ * Hardcoded default Perps notification preferences. Applied when notification
+ * preferences are initialized for the first time.
+ */
+exports.DEFAULT_PERPS_PREFERENCES = {
+    inAppNotificationsEnabled: true,
+    pushNotificationsEnabled: true,
+};
+/**
+ * Hardcoded default Social AI notification preferences. Applied when
+ * notification preferences are initialized for the first time.
+ */
+exports.DEFAULT_SOCIAL_AI_PREFERENCES = {
+    inAppNotificationsEnabled: true,
+    pushNotificationsEnabled: true,
+    txAmountLimit: 500,
+    mutedTraderProfileIds: [],
+};
+var authenticated_user_storage_2 = require("@metamask/authenticated-user-storage");
+Object.defineProperty(exports, "DEFAULT_AGENTIC_CLI_PREFERENCES", { enumerable: true, get: function () { return authenticated_user_storage_2.DEFAULT_AGENTIC_CLI_PREFERENCES; } });
+Object.defineProperty(exports, "DEFAULT_PRICE_ALERT_PREFERENCES", { enumerable: true, get: function () { return authenticated_user_storage_2.DEFAULT_PRICE_ALERT_PREFERENCES; } });
+/**
+ * Builds wallet-activity preferences from the keyring's current accounts.
+ *
+ * @param accounts - The keyring accounts to build wallet-activity entries for.
+ * @returns An array of wallet-activity account entries (lower-cased addresses).
+ */
+const buildWalletActivityAccounts = (accounts) => accounts.map(({ address, enabled }) => {
+    const lowercased = address.toLowerCase();
+    return {
+        address: lowercased,
+        enabled,
+    };
+});
+/**
+ * Builds wallet-activity initialization from the Trigger API. If Trigger has no
+ * enabled entries for the current keyring accounts, this is a first-time
+ * notification setup and all current accounts should start enabled.
+ *
+ * @param bearerToken - JWT used to query Trigger API.
+ * @param accounts - The keyring accounts to initialize.
+ * @param env - The environment to use for the Trigger API call.
+ * @returns Wallet-activity account initialization entries.
+ */
+const buildWalletActivityAccountsFromTriggerConfig = async (bearerToken, accounts, env) => {
+    const triggerConfig = await (0, api_notifications_js_1.getNotificationsApiConfigCached)(bearerToken, accounts, env);
+    const triggerConfigByAddress = new Map(triggerConfig.map(({ address, enabled }) => [
+        address.toLowerCase(),
+        enabled,
+    ]));
+    const hasEnabledTriggerAccount = accounts.some((address) => triggerConfigByAddress.get(address.toLowerCase()) === true);
+    return accounts.map((address) => ({
+        address,
+        enabled: hasEnabledTriggerAccount
+            ? (triggerConfigByAddress.get(address.toLowerCase()) ?? false)
+            : true,
+    }));
+};
+/**
+ * Builds a fresh `NotificationPreferences` blob using hardcoded defaults for
+ * Perps, Social AI, and Agentic CLI, the supplied wallet-activity accounts and
+ * the user's marketing/product-announcement flags.
+ *
+ * @param walletActivityAccounts - The wallet-activity account config to initialize.
+ * @param hasMarketingConsent - Whether marketing push notifications should be enabled.
+ * @param productAnnouncementEnabled - Whether marketing in-app notifications should be enabled.
+ * @returns A complete `NotificationPreferences` object.
+ */
+const buildFreshPreferences = (walletActivityAccounts, hasMarketingConsent, productAnnouncementEnabled) => ({
+    walletActivity: {
+        inAppNotificationsEnabled: true,
+        pushNotificationsEnabled: true,
+        accounts: buildWalletActivityAccounts(walletActivityAccounts),
+    },
+    marketing: {
+        inAppNotificationsEnabled: productAnnouncementEnabled,
+        pushNotificationsEnabled: hasMarketingConsent,
+    },
+    perps: { ...exports.DEFAULT_PERPS_PREFERENCES },
+    socialAI: { ...exports.DEFAULT_SOCIAL_AI_PREFERENCES },
+    agenticCli: { ...authenticated_user_storage_1.DEFAULT_AGENTIC_CLI_PREFERENCES },
+    priceAlerts: { ...authenticated_user_storage_1.DEFAULT_PRICE_ALERT_PREFERENCES },
+});
+const MESSENGER_EXPOSED_METHODS = [
+    'init',
+    'enablePushNotifications',
+    'disablePushNotifications',
+    'checkAccountsPresence',
+    'setFeatureAnnouncementsEnabled',
+    'createOnChainTriggers',
+    'enableMetamaskNotifications',
+    'disableNotificationServices',
+    'disableAccounts',
+    'enableAccounts',
+    'fetchAndUpdateMetamaskNotifications',
+    'getNotificationsByType',
+    'deleteNotificationById',
+    'deleteNotificationsById',
+    'markMetamaskNotificationsAsRead',
+    'updateMetamaskNotificationsList',
+    'sendPerpPlaceOrderNotification',
+];
+/**
+ * Controller that enables wallet notifications and feature announcements
+ */
+class NotificationServicesController extends base_controller_1.BaseController {
+    /**
+     * Creates a NotificationServicesController instance.
+     *
+     * @param args - The arguments to this function.
+     * @param args.messenger - Messenger used to communicate with BaseV2 controller.
+     * @param args.state - Initial state to set on this controller.
+     * @param args.env - environment variables for a given controller.
+     * @param args.env.featureAnnouncements - env variables for feature announcements.
+     * @param args.env.locale - users locale for better dynamic server notifications
+     * @param args.env.env - the environment to use for the controller
+     */
+    constructor({ messenger, state, env, }) {
+        super({
+            messenger,
+            metadata,
+            name: controllerName,
+            state: { ...exports.defaultState, ...state },
+        });
+        _NotificationServicesController_instances.add(this);
+        _NotificationServicesController_keyringController.set(this, {
+            isUnlocked: false,
+            setupLockedStateSubscriptions: (onUnlock) => {
+                const { isUnlocked } = this.messenger.call('KeyringController:getState');
+                __classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked = isUnlocked;
+                this.messenger.subscribe('KeyringController:unlock', () => {
+                    __classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked = true;
+                    // messaging system cannot await promises
+                    // we don't need to wait for a result on this.
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    onUnlock();
+                });
+                this.messenger.subscribe('KeyringController:lock', () => {
+                    __classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked = false;
+                });
+            },
+        });
+        _NotificationServicesController_auth.set(this, {
+            getBearerToken: async () => {
+                return await this.messenger.call('AuthenticationController:getBearerToken');
+            },
+            isSignedIn: () => {
+                return this.messenger.call('AuthenticationController:isSignedIn');
+            },
+            signIn: async () => {
+                return await this.messenger.call('AuthenticationController:performSignIn');
+            },
+        });
+        _NotificationServicesController_pushNotifications.set(this, {
+            // Flag to check is notifications have been setup when the browser/extension is initialized.
+            // We want to re-initialize push notifications when the browser/extension is refreshed
+            // To ensure we subscribe to the most up-to-date notifications
+            isSetup: false,
+            subscribeToPushNotifications: async () => {
+                await this.messenger.call('NotificationServicesPushController:subscribeToPushNotifications');
+            },
+            enablePushNotifications: async (addresses) => {
+                try {
+                    await this.messenger.call('NotificationServicesPushController:enablePushNotifications', addresses);
+                }
+                catch {
+                    // Do nothing, failing silently.
+                }
+            },
+            addPushNotificationLinks: async (addresses) => {
+                try {
+                    await this.messenger.call('NotificationServicesPushController:addPushNotificationLinks', addresses);
+                }
+                catch {
+                    // Do nothing, failing silently.
+                }
+            },
+            disablePushNotifications: async () => {
+                try {
+                    await this.messenger.call('NotificationServicesPushController:disablePushNotifications');
+                }
+                catch {
+                    // Do nothing, failing silently.
+                }
+            },
+            deletePushNotificationLinks: async (addresses) => {
+                try {
+                    await this.messenger.call('NotificationServicesPushController:deletePushNotificationLinks', addresses);
+                }
+                catch {
+                    // Do nothing, failing silently.
+                }
+            },
+            subscribe: () => {
+                // Coalesce pushes: at most one fetch in-flight, one queued.
+                // Re-fetch after completion because the new row may not be visible yet when the push arrives.
+                let pushFetchInFlight = false;
+                let pendingPushRefetch = false;
+                const fetchOnPush = async () => {
+                    pushFetchInFlight = true;
+                    try {
+                        await this.fetchAndUpdateMetamaskNotifications();
+                    }
+                    finally {
+                        pushFetchInFlight = false;
+                        if (pendingPushRefetch) {
+                            pendingPushRefetch = false;
+                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                            fetchOnPush();
+                        }
+                    }
+                };
+                this.messenger.subscribe('NotificationServicesPushController:onNewNotifications', () => {
+                    if (pushFetchInFlight) {
+                        pendingPushRefetch = true;
+                        return;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    fetchOnPush();
+                });
+            },
+            initializePushNotifications: async () => {
+                if (!this.state.isNotificationServicesEnabled) {
+                    return;
+                }
+                if (__classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").isSetup) {
+                    return;
+                }
+                // If wallet is unlocked, we can create a fresh push subscription
+                // Otherwise we can subscribe to original subscription
+                try {
+                    if (!__classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked) {
+                        throw new Error('Keyring is locked');
+                    }
+                    await this.enablePushNotifications();
+                    __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").isSetup = true;
+                }
+                catch {
+                    await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f")
+                        .subscribeToPushNotifications()
+                        .catch(() => {
+                        // do nothing
+                    });
+                }
+            },
+        });
+        _NotificationServicesController_accounts.set(this, {
+            // Flag to ensure we only setup once
+            isNotificationAccountsSetup: false,
+            getNotificationAccounts: () => {
+                const { keyrings } = this.messenger.call('KeyringController:getState');
+                const keyringAccounts = [
+                    ...new Set(keyrings
+                        .flatMap((keyring) => keyring.accounts)
+                        .map((address) => {
+                        try {
+                            return (0, controller_utils_1.toChecksumHexAddress)(address);
+                        }
+                        catch {
+                            return null;
+                        }
+                    })
+                        .filter((address) => address !== null && (0, controller_utils_1.isValidHexAddress)(address))),
+                ];
+                return keyringAccounts.length > 0 ? keyringAccounts : null;
+            },
+            /**
+             * Used to get list of addresses from keyring (wallet addresses)
+             *
+             * @returns addresses removed, added, and latest list of addresses
+             */
+            listAccounts: () => {
+                // Get previous and current account sets
+                const nonChecksumAccounts = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").getNotificationAccounts();
+                if (!nonChecksumAccounts) {
+                    return {
+                        accountsAdded: [],
+                        accountsRemoved: [],
+                        accounts: [],
+                    };
+                }
+                const accounts = nonChecksumAccounts
+                    .map((address) => (0, controller_utils_1.toChecksumHexAddress)(address))
+                    .filter((address) => (0, controller_utils_1.isValidHexAddress)(address));
+                const currentAccountsSet = new Set(accounts);
+                const prevAccountsSet = new Set(this.state.subscriptionAccountsSeen);
+                // Invalid value you cannot have zero accounts
+                // Only occurs when the Accounts controller is initializing.
+                if (accounts.length === 0) {
+                    return {
+                        accountsAdded: [],
+                        accountsRemoved: [],
+                        accounts: [],
+                    };
+                }
+                // Calculate added and removed addresses
+                const accountsAdded = accounts.filter((account) => !prevAccountsSet.has(account));
+                const accountsRemoved = [...prevAccountsSet.values()].filter((account) => !currentAccountsSet.has(account));
+                // Update accounts seen
+                this.update((state) => {
+                    state.subscriptionAccountsSeen = [...currentAccountsSet];
+                });
+                return {
+                    accountsAdded,
+                    accountsRemoved,
+                    accounts,
+                };
+            },
+            /**
+             * Initializes the cache/previous list. This is handy so we have an accurate in-mem state of the previous list of accounts.
+             */
+            initialize: () => {
+                if (__classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked &&
+                    !__classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").isNotificationAccountsSetup) {
+                    __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+                    __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").isNotificationAccountsSetup = true;
+                }
+            },
+            /**
+             * Subscription to any state change in the keyring controller (aka wallet accounts).
+             * We can call the `listAccounts` defined above to find out about any accounts added, removed
+             * And call effects to subscribe/unsubscribe to notifications.
+             */
+            subscribe: () => {
+                const debouncedUpdateAccountNotifications = (0, lodash_1.debounce)(async (totalAccounts, prevTotalAccounts) => {
+                    const hasTotalAccountsChanged = totalAccounts !== prevTotalAccounts;
+                    if (!this.state.isNotificationServicesEnabled ||
+                        !hasTotalAccountsChanged) {
+                        return;
+                    }
+                    const { accountsAdded, accountsRemoved } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+                    const promises = [];
+                    if (accountsAdded.length > 0) {
+                        promises.push(this.enableAccounts(accountsAdded));
+                    }
+                    if (accountsRemoved.length > 0) {
+                        promises.push(this.disableAccounts(accountsRemoved));
+                    }
+                    await Promise.allSettled(promises);
+                }, exports.ACCOUNTS_UPDATE_DEBOUNCE_TIME_MS);
+                this.messenger.subscribe('KeyringController:stateChange', 
+                // Using void return for async callback - result is intentionally ignored
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                debouncedUpdateAccountNotifications, (state) => {
+                    return (state?.keyrings?.flatMap?.((keyring) => keyring.accounts)?.length ??
+                        0);
+                });
+            },
+        });
+        _NotificationServicesController_locale.set(this, void 0);
+        _NotificationServicesController_featureAnnouncementEnv.set(this, void 0);
+        _NotificationServicesController_env.set(this, void 0);
+        __classPrivateFieldSet(this, _NotificationServicesController_featureAnnouncementEnv, env.featureAnnouncements, "f");
+        __classPrivateFieldSet(this, _NotificationServicesController_locale, env.locale ?? (() => 'en'), "f");
+        __classPrivateFieldSet(this, _NotificationServicesController_env, env.env ?? 'prd', "f");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_clearLoadingStates).call(this);
+    }
+    init() {
+        __classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").setupLockedStateSubscriptions(async () => {
+            __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").initialize();
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").initializePushNotifications();
+        });
+        __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").initialize();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").initializePushNotifications();
+        __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").subscribe();
+        __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").subscribe();
+    }
+    /**
+     * Public method to expose enabling push notifications
+     */
+    async enablePushNotifications() {
+        try {
+            const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
+            const enabledAddresses = (preferences?.walletActivity.accounts ?? [])
+                .filter((account) => account.enabled)
+                .map((account) => account.address);
+            if (enabledAddresses.length > 0) {
+                await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(enabledAddresses);
+            }
+        }
+        catch {
+            // Do nothing, failing silently.
+        }
+    }
+    /**
+     * Public method to expose disabling push notifications
+     */
+    async disablePushNotifications() {
+        await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
+    }
+    async checkAccountsPresence(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, true);
+            const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
+            const enabledByAddress = new Map((preferences?.walletActivity.accounts ?? []).map((account) => [
+                account.address.toLowerCase(),
+                account.enabled,
+            ]));
+            const result = {};
+            for (const address of accounts) {
+                result[address] = enabledByAddress.get(address.toLowerCase()) ?? false;
+            }
+            return result;
+        }
+        catch (error) {
+            loglevel_1.default.error('Failed to check accounts presence', error);
+            throw error;
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, false);
+        }
+    }
+    /**
+     * Sets the enabled state of feature announcements.
+     *
+     * **Action** - used in the notification settings to enable/disable feature announcements.
+     *
+     * @param featureAnnouncementsEnabled - A boolean value indicating the desired enabled state of the feature announcements.
+     * @async
+     * @throws {Error} If fails to update
+     */
+    async setFeatureAnnouncementsEnabled(featureAnnouncementsEnabled) {
+        try {
+            this.update((state) => {
+                state.isFeatureAnnouncementsEnabled = featureAnnouncementsEnabled;
+            });
+        }
+        catch (error) {
+            loglevel_1.default.error('Unable to toggle feature announcements', error);
+            throw new Error('Unable to toggle feature announcements');
+        }
+    }
+    /**
+     * This creates/re-creates on-chain triggers defined in User Storage.
+     *
+     * **Action** - Used during Sign In / Enabling of notifications.
+     *
+     * Notification preferences are initialized only when
+     * {@link AuthenticatedUserStorageService} has no stored preferences yet.
+     * Existing preferences are left as-is.
+     *
+     * @param opts - optional options to mutate this functionality
+     * @param opts.hasMarketingConsent - The user's marketing-consent flag.
+     * Used only during initialization to seed marketing push notifications.
+     * @param opts.productAnnouncementEnabled - The user's product-announcement flag.
+     * Used only during initialization to seed marketing in-app notifications.
+     * @param opts.registerPushNotifications - Whether to attempt FCM/device push registration.
+     * @returns The updated or newly created user storage.
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async createOnChainTriggers(opts = {}) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            const { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+            // 1. Read existing AUS notification preferences and initialize only if absent.
+            const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
+            const hasMarketingConsent = Boolean(opts?.hasMarketingConsent);
+            const productAnnouncementEnabled = Boolean(opts?.productAnnouncementEnabled);
+            let nextPreferences;
+            if (preferences === null) {
+                const walletActivityAccounts = await buildWalletActivityAccountsFromTriggerConfig(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+                nextPreferences = buildFreshPreferences(walletActivityAccounts, hasMarketingConsent, productAnnouncementEnabled);
+            }
+            if (nextPreferences) {
+                await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', nextPreferences, __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform);
+            }
+            const effectivePreferences = nextPreferences ?? preferences;
+            const accountsWithNotifications = (effectivePreferences?.walletActivity.accounts ?? [])
+                .filter((account) => account.enabled)
+                .map((account) => account.address);
+            if (opts.registerPushNotifications ?? true) {
+                // Attempt FCM/device registration only; clients must request OS permission separately.
+                __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f")
+                    .enablePushNotifications(accountsWithNotifications)
+                    .catch(() => {
+                    // Do Nothing
+                });
+            }
+            // Update the state of the controller
+            this.update((state) => {
+                // User is re-subscribing (daily resub to get latest notifications)
+                if (state.isNotificationServicesEnabled) {
+                    // Keep their existing preferences on re-subscribe
+                    // No state updates needed - preserving user's current settings
+                }
+                else {
+                    // User is turning on notifications from a disabled state
+                    state.isNotificationServicesEnabled = true;
+                    state.isFeatureAnnouncementsEnabled = true;
+                    state.isMetamaskNotificationsFeatureSeen = true;
+                }
+            });
+        }
+        catch (error) {
+            loglevel_1.default.error('Failed to create On Chain triggers', error);
+            throw new Error('Failed to create On Chain triggers');
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+        }
+    }
+    /**
+     * Enables all MetaMask notifications for the user.
+     * This is identical flow when initializing notifications for the first time.
+     *
+     * @param opts - Optional options to mutate this functionality.
+     * @throws {Error} If there is an error during the process of enabling notifications.
+     */
+    async enableMetamaskNotifications(opts = {}) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_enableAuth).call(this);
+            await this.createOnChainTriggers(opts);
+        }
+        catch (error) {
+            loglevel_1.default.error('Unable to enable notifications', error);
+            throw new Error('Unable to enable notifications');
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+        }
+    }
+    /**
+     * Disables all MetaMask notifications for the user.
+     * This method ensures that the user is authenticated, retrieves all linked accounts,
+     * and disables on-chain triggers for each account. It also sets the global notification
+     * settings for MetaMask, feature announcements to false.
+     *
+     * @throws {Error} If the user is not authenticated or if there is an error during the process.
+     */
+    async disableNotificationServices() {
+        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+        // Attempt Disable Push Notifications
+        try {
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
+        }
+        catch {
+            // Do nothing
+        }
+        // Update State: remove non-permitted notifications & disable flags
+        const snapNotifications = this.state.metamaskNotificationsList.filter((notification) => notification.type === notification_schema_js_1.TRIGGER_TYPES.SNAP);
+        this.update((state) => {
+            state.isNotificationServicesEnabled = false;
+            state.isFeatureAnnouncementsEnabled = false;
+            // reassigning the notifications list with just snaps
+            // since the disable shouldn't affect snaps notifications
+            state.metamaskNotificationsList = snapNotifications;
+        });
+        // Finish Updating State
+        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+    }
+    /**
+     * Deletes on-chain triggers associated with a specific account/s.
+     * This method performs several key operations:
+     * 1. Validates Auth
+     * 2. Deletes accounts
+     * (note) We do not need to look through push notifications as we've deleted triggers
+     *
+     * **Action** - When a user disables notifications for a given account in settings.
+     *
+     * @param accounts - The account for which on-chain triggers are to be deleted.
+     * @returns A promise that resolves to void or an object containing a success message.
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async disableAccounts(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
+            // Sign-in gate.
+            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerWalletActivityAddresses).call(this, accounts.map((address) => ({ address, enabled: false })));
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").deletePushNotificationLinks(accounts);
+        }
+        catch {
+            throw new Error('Failed to delete OnChain triggers');
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_clearUpdatingAccountsState).call(this, accounts);
+        }
+    }
+    /**
+     * Updates/Creates on-chain triggers for a specific account.
+     *
+     * This method performs several key operations:
+     * 1. Validates Auth & Storage
+     * 2. Finds and creates any missing triggers associated with the account
+     * 3. Enables any related push notifications
+     * 4. Updates Storage to reflect new state.
+     *
+     * **Action** - When a user enables notifications for an account
+     *
+     * @param accounts - List of accounts you want to update.
+     * @returns A promise that resolves to the updated user storage.
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async enableAccounts(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
+            // Sign-in gate.
+            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerWalletActivityAddresses).call(this, accounts.map((address) => ({ address, enabled: true })));
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").addPushNotificationLinks(accounts);
+        }
+        catch (error) {
+            loglevel_1.default.error('Failed to update OnChain triggers', error);
+            throw new Error('Failed to update OnChain triggers');
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_clearUpdatingAccountsState).call(this, accounts);
+        }
+    }
+    /**
+     * Fetches the list of metamask notifications.
+     * This includes OnChain notifications; Feature Announcements; and Snap Notifications.
+     *
+     * **Action** - When a user views the notification list page/dropdown
+     *
+     * @param previewToken - the preview token to use if needed
+     * @returns A promise that resolves to the list of notifications.
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async fetchAndUpdateMetamaskNotifications(previewToken) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, true);
+            // This is used by Feature Announcement & On Chain
+            // Not used by Snaps
+            const isGlobalNotifsEnabled = this.state.isNotificationServicesEnabled;
+            const notificationPreferences = isGlobalNotifsEnabled
+                ? await this.messenger
+                    .call('AuthenticatedUserStorageService:getNotificationPreferences')
+                    .catch(() => null)
+                : null;
+            // Raw Feature Notifications
+            const rawAnnouncements = isGlobalNotifsEnabled &&
+                notificationPreferences?.marketing.inAppNotificationsEnabled
+                ? await (0, feature_announcements_js_1.getFeatureAnnouncementNotifications)(__classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f"), previewToken).catch(() => [])
+                : [];
+            // Raw On Chain Notifications
+            const rawOnChainNotifications = [];
+            if (isGlobalNotifsEnabled) {
+                try {
+                    const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+                    const addressesWithNotifications = (notificationPreferences?.walletActivity.accounts ?? [])
+                        .filter((account) => account.enabled)
+                        .map((account) => account.address);
+                    const notifications = await (0, api_notifications_js_1.getAPINotifications)(bearerToken, addressesWithNotifications, __classPrivateFieldGet(this, _NotificationServicesController_locale, "f").call(this), __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => []);
+                    rawOnChainNotifications.push(...notifications);
+                }
+                catch {
+                    // Do nothing
+                }
+            }
+            // Snap Notifications (original)
+            // We do not want to remove them
+            const snapNotifications = this.state.metamaskNotificationsList.filter((notification) => notification.type === notification_schema_js_1.TRIGGER_TYPES.SNAP);
+            const readIds = this.state.metamaskNotificationsReadList;
+            // Combine Notifications
+            const metamaskNotifications = [
+                ...(0, process_notifications_js_1.processAndFilterNotifications)(rawAnnouncements, readIds),
+                ...(0, process_notifications_js_1.processAndFilterNotifications)(rawOnChainNotifications, readIds),
+                ...snapNotifications,
+            ];
+            // Sort Notifications
+            metamaskNotifications.sort((notificationA, notificationB) => new Date(notificationB.createdAt).getTime() -
+                new Date(notificationA.createdAt).getTime());
+            // Update State
+            this.update((state) => {
+                state.metamaskNotificationsList = metamaskNotifications;
+            });
+            this.messenger.publish(`${controllerName}:notificationsListUpdated`, this.state.metamaskNotificationsList);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            return metamaskNotifications;
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            loglevel_1.default.error('Failed to fetch notifications', error);
+            throw new Error('Failed to fetch notifications');
+        }
+    }
+    /**
+     * Gets the specified type of notifications from state.
+     *
+     * @param type - The trigger type.
+     * @returns An array of notifications of the passed in type.
+     * @throws Throws an error if an invalid trigger type is passed.
+     */
+    getNotificationsByType(type) {
+        (0, utils_1.assert)(Object.values(notification_schema_js_1.TRIGGER_TYPES).includes(type), 'Invalid trigger type.');
+        return this.state.metamaskNotificationsList.filter((notification) => notification.type === type);
+    }
+    /**
+     * Used to delete a notification by id.
+     *
+     * Note: This function should only be used for notifications that are stored
+     * in this controller directly, currently only snaps notifications.
+     *
+     * @param id - The id of the notification to delete.
+     */
+    async deleteNotificationById(id) {
+        const fetchedNotification = this.state.metamaskNotificationsList.find((notification) => notification.id === id);
+        (0, utils_1.assert)(fetchedNotification, 'The notification to be deleted does not exist.');
+        (0, utils_1.assert)(locallyPersistedNotificationTypes.has(fetchedNotification.type), `The notification type of "${
+        // notifications are guaranteed to have type properties which equate to strings
+        fetchedNotification.type}" is not locally persisted, only the following types can use this function: ${[
+            ...locallyPersistedNotificationTypes,
+        ].join(', ')}.`);
+        const newList = this.state.metamaskNotificationsList.filter((notification) => notification.id !== id);
+        this.update((state) => {
+            state.metamaskNotificationsList = newList;
+        });
+    }
+    /**
+     * Used to batch delete notifications by id.
+     *
+     * Note: This function should only be used for notifications that are stored
+     * in this controller directly, currently only snaps notifications.
+     *
+     * @param ids - The ids of the notifications to delete.
+     */
+    async deleteNotificationsById(ids) {
+        for (const id of ids) {
+            await this.deleteNotificationById(id);
+        }
+        this.messenger.publish(`${controllerName}:notificationsListUpdated`, this.state.metamaskNotificationsList);
+    }
+    /**
+     * Marks specified metamask notifications as read.
+     *
+     * @param notifications - An array of notifications to be marked as read. Each notification should include its type and read status.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    async markMetamaskNotificationsAsRead(notifications) {
+        let onchainNotificationIds = [];
+        let featureAnnouncementNotificationIds = [];
+        let snapNotificationIds = [];
+        try {
+            const [onChainNotifications, featureAnnouncementNotifications, snapNotifications,] = notifications.reduce((allNotifications, notification) => {
+                if (!notification.isRead) {
+                    switch (notification.type) {
+                        case notification_schema_js_1.TRIGGER_TYPES.FEATURES_ANNOUNCEMENT:
+                            allNotifications[1].push(notification);
+                            break;
+                        case notification_schema_js_1.TRIGGER_TYPES.SNAP:
+                            allNotifications[2].push(notification);
+                            break;
+                        default:
+                            allNotifications[0].push(notification);
+                    }
+                }
+                return allNotifications;
+            }, [[], [], []]);
+            // Mark On-Chain Notifications as Read
+            if (onChainNotifications.length > 0) {
+                const bearerToken = await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").getBearerToken();
+                if (bearerToken) {
+                    onchainNotificationIds = onChainNotifications.map((notification) => notification.id);
+                    await (0, api_notifications_js_1.markNotificationsAsRead)(bearerToken, onchainNotificationIds, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => {
+                        onchainNotificationIds = [];
+                        loglevel_1.default.warn('Unable to mark onchain notifications as read');
+                    });
+                }
+            }
+            // Mark Off-Chain notifications as Read
+            if (featureAnnouncementNotifications.length > 0) {
+                featureAnnouncementNotificationIds =
+                    featureAnnouncementNotifications.map((notification) => notification.id);
+            }
+            if (snapNotifications.length > 0) {
+                snapNotificationIds = snapNotifications.map((notification) => notification.id);
+            }
+        }
+        catch (error) {
+            loglevel_1.default.warn('Something failed when marking notifications as read', error);
+        }
+        // Update the state (state is also used on counter & badge)
+        this.update((state) => {
+            const currentReadList = state.metamaskNotificationsReadList;
+            const newReadIds = [
+                ...featureAnnouncementNotificationIds,
+                ...snapNotificationIds,
+            ];
+            state.metamaskNotificationsReadList = [
+                ...new Set([...currentReadList, ...newReadIds]),
+            ];
+            state.metamaskNotificationsList = state.metamaskNotificationsList.map((notification) => {
+                if (newReadIds.includes(notification.id) ||
+                    onchainNotificationIds.includes(notification.id)) {
+                    if (notification.type === notification_schema_js_1.TRIGGER_TYPES.SNAP) {
+                        return {
+                            ...notification,
+                            isRead: true,
+                            readDate: new Date().toISOString(),
+                        };
+                    }
+                    return { ...notification, isRead: true };
+                }
+                return notification;
+            });
+        });
+        this.messenger.publish(`${controllerName}:markNotificationsAsRead`, this.state.metamaskNotificationsList);
+    }
+    /**
+     * Updates the list of MetaMask notifications by adding a new notification at the beginning of the list.
+     * This method ensures that the most recent notification is displayed first in the UI.
+     *
+     * @param notification - The new notification object to be added to the list.
+     * @returns A promise that resolves when the notification list has been successfully updated.
+     */
+    async updateMetamaskNotificationsList(notification) {
+        if (this.state.metamaskNotificationsList.some((existingNotification) => existingNotification.id === notification.id)) {
+            return;
+        }
+        const processedNotification = (0, process_notifications_js_1.safeProcessNotification)(notification);
+        if (processedNotification) {
+            this.update((state) => {
+                const existingNotificationIds = new Set(state.metamaskNotificationsList.map((existingNotification) => existingNotification.id));
+                // Add the new notification only if its ID is not already present in the list
+                if (!existingNotificationIds.has(processedNotification.id)) {
+                    state.metamaskNotificationsList = [
+                        processedNotification,
+                        ...state.metamaskNotificationsList,
+                    ];
+                }
+            });
+            this.messenger.publish(`${controllerName}:notificationsListUpdated`, this.state.metamaskNotificationsList);
+        }
+    }
+    /**
+     * Creates an perp order notification subscription.
+     * Requires notifications and auth to be enabled to start receiving this notifications
+     *
+     * @param input perp input
+     */
+    async sendPerpPlaceOrderNotification(input) {
+        try {
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            await (0, perp_notifications_js_1.createPerpOrderNotification)(bearerToken, input);
+        }
+        catch {
+            // Do Nothing
+        }
+    }
+}
+exports.NotificationServicesController = NotificationServicesController;
+_NotificationServicesController_keyringController = new WeakMap(), _NotificationServicesController_auth = new WeakMap(), _NotificationServicesController_pushNotifications = new WeakMap(), _NotificationServicesController_accounts = new WeakMap(), _NotificationServicesController_locale = new WeakMap(), _NotificationServicesController_featureAnnouncementEnv = new WeakMap(), _NotificationServicesController_env = new WeakMap(), _NotificationServicesController_instances = new WeakSet(), _NotificationServicesController_clearLoadingStates = function _NotificationServicesController_clearLoadingStates() {
+    this.update((state) => {
+        state.isUpdatingMetamaskNotifications = false;
+        state.isCheckingAccountsPresence = false;
+        state.isFetchingMetamaskNotifications = false;
+        state.isUpdatingMetamaskNotificationsAccount = [];
+    });
+}, _NotificationServicesController_assertAuthEnabled = function _NotificationServicesController_assertAuthEnabled() {
+    if (!__classPrivateFieldGet(this, _NotificationServicesController_auth, "f").isSignedIn()) {
+        this.update((state) => {
+            state.isNotificationServicesEnabled = false;
+        });
+        throw new Error('User is not signed in.');
+    }
+}, _NotificationServicesController_enableAuth = async function _NotificationServicesController_enableAuth() {
+    const isSignedIn = __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").isSignedIn();
+    if (!isSignedIn) {
+        await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").signIn();
+    }
+}, _NotificationServicesController_getBearerToken = async function _NotificationServicesController_getBearerToken() {
+    __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertAuthEnabled).call(this);
+    const bearerToken = await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").getBearerToken();
+    if (!bearerToken) {
+        throw new Error('Missing BearerToken');
+    }
+    return { bearerToken };
+}, _NotificationServicesController_registerWalletActivityAddresses = 
+/**
+ * Updates the `walletActivity.accounts` entries in the user's
+ * notification-preferences blob in {@link AuthenticatedUserStorageService}.
+ *
+ * `putNotificationPreferences` replaces the entire blob, so we read the
+ * current preferences, merge the supplied updates into
+ * `walletActivity.accounts`, and write the result back. This helper is only
+ * meant to be used for incremental updates (enable/disable individual
+ * accounts) after the preferences blob has already been initialized via
+ * {@link createOnChainTriggers}; callers should not rely on it to perform
+ * first-time initialization.
+ *
+ * @param updates - Addresses to register, each with the desired `enabled` flag
+ */
+async function _NotificationServicesController_registerWalletActivityAddresses(updates) {
+    if (updates.length === 0) {
+        return;
+    }
+    const currentPreferences = await this.messenger
+        .call('AuthenticatedUserStorageService:getNotificationPreferences')
+        .catch((error) => {
+        loglevel_1.default.error('Failed to get notification preferences. Re-initializing them instead.', error);
+        // TODO: return null once validation error captured
+        // return null;
+        throw error;
+    });
+    if (!currentPreferences) {
+        loglevel_1.default.warn('Preferences blob not yet initialized; run `createOnChainTriggers` first.');
+        return;
+    }
+    const accountsByAddress = new Map(currentPreferences.walletActivity.accounts.map((account) => [
+        account.address.toLowerCase(),
+        { ...account, address: account.address.toLowerCase() },
+    ]));
+    for (const update of updates) {
+        const address = update.address.toLowerCase();
+        accountsByAddress.set(address, { address, enabled: update.enabled });
+    }
+    const nextPreferences = {
+        ...currentPreferences,
+        walletActivity: {
+            ...currentPreferences.walletActivity,
+            accounts: [...accountsByAddress.values()],
+        },
+    };
+    await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', nextPreferences, __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform);
+}, _NotificationServicesController_setIsUpdatingMetamaskNotifications = function _NotificationServicesController_setIsUpdatingMetamaskNotifications(isUpdatingMetamaskNotifications) {
+    this.update((state) => {
+        state.isUpdatingMetamaskNotifications = isUpdatingMetamaskNotifications;
+    });
+}, _NotificationServicesController_setIsFetchingMetamaskNotifications = function _NotificationServicesController_setIsFetchingMetamaskNotifications(isFetchingMetamaskNotifications) {
+    this.update((state) => {
+        state.isFetchingMetamaskNotifications = isFetchingMetamaskNotifications;
+    });
+}, _NotificationServicesController_setIsCheckingAccountsPresence = function _NotificationServicesController_setIsCheckingAccountsPresence(isCheckingAccountsPresence) {
+    this.update((state) => {
+        state.isCheckingAccountsPresence = isCheckingAccountsPresence;
+    });
+}, _NotificationServicesController_updateUpdatingAccountsState = function _NotificationServicesController_updateUpdatingAccountsState(accounts) {
+    this.update((state) => {
+        const uniqueAccounts = new Set([
+            ...state.isUpdatingMetamaskNotificationsAccount,
+            ...accounts,
+        ]);
+        state.isUpdatingMetamaskNotificationsAccount = Array.from(uniqueAccounts);
+    });
+}, _NotificationServicesController_clearUpdatingAccountsState = function _NotificationServicesController_clearUpdatingAccountsState(accounts) {
+    this.update((state) => {
+        state.isUpdatingMetamaskNotificationsAccount =
+            state.isUpdatingMetamaskNotificationsAccount.filter((existingAccount) => !accounts.includes(existingAccount));
+    });
+};
+//# sourceMappingURL=NotificationServicesController.cjs.map