@metamask-previews/notification-services-controller 27.0.2-preview-6eff555ee → 28.0.0-preview-0a30e47

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

@@ -1,34 +1,14 @@
-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 _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_registerPushNotifications, _NotificationServicesController_setIsUpdatingMetamaskNotifications, _NotificationServicesController_setIsFetchingMetamaskNotifications, _NotificationServicesController_setIsCheckingAccountsPresence, _NotificationServicesController_updateUpdatingAccountsState, _NotificationServicesController_clearUpdatingAccountsState;
-function $importDefault(module) {
-    if (module?.__esModule) {
-        return module.default;
-    }
-    return module;
-}
-import { DEFAULT_AGENTIC_CLI_PREFERENCES, DEFAULT_PRICE_ALERT_PREFERENCES } from "@metamask/authenticated-user-storage";
-import { BaseController } from "@metamask/base-controller";
-import { isValidHexAddress, toChecksumHexAddress } from "@metamask/controller-utils";
-import { assert } from "@metamask/utils";
-import $lodash from "lodash";
-const { debounce } = $lodash;
-import $log from "loglevel";
-const log = $importDefault($log);
-import { TRIGGER_TYPES } from "./constants/notification-schema.mjs";
-import { processAndFilterNotifications, safeProcessNotification } from "./processors/process-notifications.mjs";
-import { getAPINotifications, getNotificationsApiConfigCached, markNotificationsAsRead, updateOnChainNotifications } from "./services/api-notifications.mjs";
-import { getFeatureAnnouncementNotifications } from "./services/feature-announcements.mjs";
-import { createPerpOrderNotification } from "./services/perp-notifications.mjs";
+import { DEFAULT_AGENTIC_CLI_PREFERENCES, DEFAULT_PRICE_ALERT_PREFERENCES, } from '@metamask/authenticated-user-storage';
+import { BaseController } from '@metamask/base-controller';
+import { isValidHexAddress, toChecksumHexAddress, } from '@metamask/controller-utils';
+import { assert } from '@metamask/utils';
+import { debounce } from 'lodash-es';
+import log from 'loglevel';
+import { TRIGGER_TYPES } from './constants/notification-schema.js';
+import { processAndFilterNotifications, safeProcessNotification, } from './processors/process-notifications.js';
+import { getAPINotifications, getNotificationsApiConfigCached, markNotificationsAsRead, updateOnChainNotifications, } from './services/api-notifications.js';
+import { getFeatureAnnouncementNotifications } from './services/feature-announcements.js';
+import { createPerpOrderNotification } from './services/perp-notifications.js';
 // Unique name for the controller
 const controllerName = 'NotificationServicesController';
 export const ACCOUNTS_UPDATE_DEBOUNCE_TIME_MS = 1000;
@@ -127,7 +107,7 @@ export const DEFAULT_SOCIAL_AI_PREFERENCES = {
     txAmountLimit: 500,
     mutedTraderProfileIds: [],
 };
-export { DEFAULT_AGENTIC_CLI_PREFERENCES, DEFAULT_PRICE_ALERT_PREFERENCES } from "@metamask/authenticated-user-storage";
+export { DEFAULT_AGENTIC_CLI_PREFERENCES, DEFAULT_PRICE_ALERT_PREFERENCES, } from '@metamask/authenticated-user-storage';
 /**
  * Returns the subset of `accounts` that has a wallet-activity subscription in
  * the Trigger API, which is the source of truth for the per-address enabled bit.
@@ -203,6 +183,233 @@ const MESSENGER_EXPOSED_METHODS = [
  * Controller that enables wallet notifications and feature announcements
  */
 export class NotificationServicesController extends BaseController {
+    #keyringController = {
+        isUnlocked: false,
+        setupLockedStateSubscriptions: (onUnlock) => {
+            const { isUnlocked } = this.messenger.call('KeyringController:getState');
+            this.#keyringController.isUnlocked = isUnlocked;
+            this.messenger.subscribe('KeyringController:unlock', () => {
+                this.#keyringController.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', () => {
+                this.#keyringController.isUnlocked = false;
+            });
+        },
+    };
+    #auth = {
+        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');
+        },
+    };
+    #pushNotifications = {
+        // 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 (this.#pushNotifications.isSetup) {
+                return;
+            }
+            // If wallet is unlocked, we can create a fresh push subscription
+            // Otherwise we can subscribe to original subscription
+            try {
+                if (!this.#keyringController.isUnlocked) {
+                    throw new Error('Keyring is locked');
+                }
+                await this.enablePushNotifications();
+                this.#pushNotifications.isSetup = true;
+            }
+            catch {
+                await this.#pushNotifications
+                    .subscribeToPushNotifications()
+                    .catch(() => {
+                    // do nothing
+                });
+            }
+        },
+    };
+    #accounts = {
+        // 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 toChecksumHexAddress(address);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((address) => address !== null && 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 = this.#accounts.getNotificationAccounts();
+            if (!nonChecksumAccounts) {
+                return {
+                    accountsAdded: [],
+                    accountsRemoved: [],
+                    accounts: [],
+                };
+            }
+            const accounts = nonChecksumAccounts
+                .map((address) => toChecksumHexAddress(address))
+                .filter((address) => 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 (this.#keyringController.isUnlocked &&
+                !this.#accounts.isNotificationAccountsSetup) {
+                this.#accounts.listAccounts();
+                this.#accounts.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 = debounce(async (totalAccounts, prevTotalAccounts) => {
+                const hasTotalAccountsChanged = totalAccounts !== prevTotalAccounts;
+                if (!this.state.isNotificationServicesEnabled ||
+                    !hasTotalAccountsChanged) {
+                    return;
+                }
+                const { accountsAdded, accountsRemoved } = this.#accounts.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);
+            }, 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);
+            });
+        },
+    };
+    #locale;
+    #featureAnnouncementEnv;
+    #env;
     /**
      * Creates a NotificationServicesController instance.
      *
@@ -221,271 +428,158 @@ export class NotificationServicesController extends BaseController {
             name: controllerName,
             state: { ...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;
-                });
-            },
+        this.#featureAnnouncementEnv = env.featureAnnouncements;
+        this.#locale = env.locale ?? (() => 'en');
+        this.#env = env.env ?? 'prd';
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        this.#clearLoadingStates();
+    }
+    init() {
+        this.#keyringController.setupLockedStateSubscriptions(async () => {
+            this.#accounts.initialize();
+            await this.#pushNotifications.initializePushNotifications();
         });
-        _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');
-            },
+        this.#accounts.initialize();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.#pushNotifications.initializePushNotifications();
+        this.#accounts.subscribe();
+        this.#pushNotifications.subscribe();
+    }
+    #clearLoadingStates() {
+        this.update((state) => {
+            state.isUpdatingMetamaskNotifications = false;
+            state.isCheckingAccountsPresence = false;
+            state.isFetchingMetamaskNotifications = false;
+            state.isUpdatingMetamaskNotificationsAccount = [];
         });
-        _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
-                    });
-                }
-            },
+    }
+    #assertAuthEnabled() {
+        if (!this.#auth.isSignedIn()) {
+            this.update((state) => {
+                state.isNotificationServicesEnabled = false;
+            });
+            throw new Error('User is not signed in.');
+        }
+    }
+    async #enableAuth() {
+        const isSignedIn = this.#auth.isSignedIn();
+        if (!isSignedIn) {
+            await this.#auth.signIn();
+        }
+    }
+    async #getBearerToken() {
+        this.#assertAuthEnabled();
+        const bearerToken = await this.#auth.getBearerToken();
+        if (!bearerToken) {
+            throw new Error('Missing BearerToken');
+        }
+        return { bearerToken };
+    }
+    /**
+     * Registers this device for push notifications on the given addresses.
+     *
+     * An empty list cannot be sent: the push API rejects a registration with no
+     * addresses, and because that request is what performs the delete-and-reinsert
+     * of the device's links, a rejection leaves the previous links in place and
+     * push keeps arriving. So "no addresses" has to mean unregistering the device.
+     *
+     * @param addresses - The addresses to receive push notifications for.
+     */
+    async #registerPushNotifications(addresses) {
+        if (addresses.length === 0) {
+            await this.#pushNotifications.disablePushNotifications();
+            return;
+        }
+        await this.#pushNotifications.enablePushNotifications(addresses);
+    }
+    /**
+     * Sets the state of notification creation process.
+     *
+     * This method updates the `isUpdatingMetamaskNotifications` state, which can be used to indicate
+     * whether the notification creation process is currently active or not. This is useful
+     * for UI elements that need to reflect the state of ongoing operations, such as loading
+     * indicators or disabled buttons during processing.
+     *
+     * @param isUpdatingMetamaskNotifications - A boolean value representing the new state of the notification creation process.
+     */
+    #setIsUpdatingMetamaskNotifications(isUpdatingMetamaskNotifications) {
+        this.update((state) => {
+            state.isUpdatingMetamaskNotifications = isUpdatingMetamaskNotifications;
         });
-        _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 toChecksumHexAddress(address);
-                        }
-                        catch {
-                            return null;
-                        }
-                    })
-                        .filter((address) => address !== null && 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) => toChecksumHexAddress(address))
-                    .filter((address) => 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 = 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);
-                }, 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);
-                });
-            },
+    }
+    /**
+     * Updates the state to indicate whether fetching of MetaMask notifications is in progress.
+     *
+     * This method is used to set the `isFetchingMetamaskNotifications` state, which can be utilized
+     * to show or hide loading indicators in the UI when notifications are being fetched.
+     *
+     * @param isFetchingMetamaskNotifications - A boolean value representing the fetching state.
+     */
+    #setIsFetchingMetamaskNotifications(isFetchingMetamaskNotifications) {
+        this.update((state) => {
+            state.isFetchingMetamaskNotifications = isFetchingMetamaskNotifications;
         });
-        _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();
+    /**
+     * Updates the state to indicate that the checking of accounts presence is in progress.
+     *
+     * This method modifies the `isCheckingAccountsPresence` state, which can be used to manage UI elements
+     * that depend on the status of account presence checks, such as displaying loading indicators or disabling
+     * buttons while the check is ongoing.
+     *
+     * @param isCheckingAccountsPresence - A boolean value indicating whether the account presence check is currently active.
+     */
+    #setIsCheckingAccountsPresence(isCheckingAccountsPresence) {
+        this.update((state) => {
+            state.isCheckingAccountsPresence = isCheckingAccountsPresence;
+        });
+    }
+    /**
+     * Updates the state to indicate that account updates are in progress.
+     * Removes duplicate accounts before updating the state.
+     *
+     * @param accounts - The accounts being updated.
+     */
+    #updateUpdatingAccountsState(accounts) {
+        this.update((state) => {
+            const uniqueAccounts = new Set([
+                ...state.isUpdatingMetamaskNotificationsAccount,
+                ...accounts,
+            ]);
+            state.isUpdatingMetamaskNotificationsAccount = Array.from(uniqueAccounts);
+        });
+    }
+    /**
+     * Clears the state indicating that account updates are complete.
+     *
+     * @param accounts - The accounts that have finished updating.
+     */
+    #clearUpdatingAccountsState(accounts) {
+        this.update((state) => {
+            state.isUpdatingMetamaskNotificationsAccount =
+                state.isUpdatingMetamaskNotificationsAccount.filter((existingAccount) => !accounts.includes(existingAccount));
         });
-        __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 { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
-            if (!__classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked || accounts.length === 0) {
+            const { accounts } = this.#accounts.listAccounts();
+            if (!this.#keyringController.isUnlocked || accounts.length === 0) {
                 // no keyring accounts could be caused by calling this function while keyring is locked
                 // it does not mean the user does not have any enabled accounts on Trigger API
                 return;
             }
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            const enabledAddresses = await getEnabledAccounts(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+            const { bearerToken } = await this.#getBearerToken();
+            const enabledAddresses = await getEnabledAccounts(bearerToken, accounts, this.#env);
             if (enabledAddresses === null) {
                 // "No addresses" unregisters the device, so an unreadable subscription
                 // list must not be treated as an empty one: leave the existing links
                 // alone until we can read the real state.
                 return;
             }
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerPushNotifications).call(this, enabledAddresses);
+            await this.#registerPushNotifications(enabledAddresses);
         }
         catch {
             // Do nothing, failing silently.
@@ -495,13 +589,13 @@ export class NotificationServicesController extends BaseController {
      * Public method to expose disabling push notifications
      */
     async disablePushNotifications() {
-        await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
+        await this.#pushNotifications.disablePushNotifications();
     }
     async checkAccountsPresence(accounts) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, true);
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            const triggerConfig = await getNotificationsApiConfigCached(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+            this.#setIsCheckingAccountsPresence(true);
+            const { bearerToken } = await this.#getBearerToken();
+            const triggerConfig = await getNotificationsApiConfigCached(bearerToken, accounts, this.#env);
             if (triggerConfig === null) {
                 // Reporting every account as disabled would misrepresent the user's
                 // settings, so surface the failure instead.
@@ -522,7 +616,7 @@ export class NotificationServicesController extends BaseController {
             throw error;
         }
         finally {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, false);
+            this.#setIsCheckingAccountsPresence(false);
         }
     }
     /**
@@ -565,14 +659,14 @@ export class NotificationServicesController extends BaseController {
      */
     async createOnChainTriggers(opts = {}) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
-            const { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
-            if (!__classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").isUnlocked || accounts.length === 0) {
+            this.#setIsUpdatingMetamaskNotifications(true);
+            const { accounts } = this.#accounts.listAccounts();
+            if (!this.#keyringController.isUnlocked || accounts.length === 0) {
                 // no keyring accounts could be caused by calling this function while keyring is locked
                 // it does not mean the user does not have any enabled accounts on Trigger API
                 return;
             }
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            const { bearerToken } = await this.#getBearerToken();
             // 1. Read existing AUS notification preferences. Their absence is what
             // marks a first-time setup, and they are initialized in step 3.
             const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
@@ -589,7 +683,7 @@ export class NotificationServicesController extends BaseController {
             // Even at first-time setup, existing subscriptions win: a user upgrading
             // from a client that never wrote a preferences blob keeps whichever
             // accounts they had already disabled.
-            let accountsWithNotifications = await getEnabledAccounts(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+            let accountsWithNotifications = await getEnabledAccounts(bearerToken, accounts, this.#env);
             if (accountsWithNotifications === null) {
                 // An unreadable subscription list is not an empty one. Subscribing
                 // every account here would re-enable ones the user had turned off, and
@@ -598,7 +692,7 @@ export class NotificationServicesController extends BaseController {
                 throw new Error('Failed to read wallet-activity subscriptions');
             }
             if (isFirstTimeSetup && accountsWithNotifications.length === 0) {
-                await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: true })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+                await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: true })), this.#env);
                 // Match the lower-case form the Trigger API echoes back, which is what
                 // every other path feeding the push API uses.
                 accountsWithNotifications = accounts.map((address) => address.toLowerCase());
@@ -609,11 +703,11 @@ export class NotificationServicesController extends BaseController {
             // failed subscribe leave the user enabled with no accounts subscribed
             // and no second chance to seed them.
             if (isFirstTimeSetup) {
-                await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', buildFreshPreferences(hasMarketingConsent, productAnnouncementEnabled), __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform);
+                await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', buildFreshPreferences(hasMarketingConsent, productAnnouncementEnabled), this.#featureAnnouncementEnv.platform);
             }
             if (opts.registerPushNotifications ?? true) {
                 // Attempt FCM/device registration only; clients must request OS permission separately.
-                __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerPushNotifications).call(this, accountsWithNotifications).catch(() => {
+                this.#registerPushNotifications(accountsWithNotifications).catch(() => {
                     // Do Nothing
                 });
             }
@@ -637,7 +731,7 @@ export class NotificationServicesController extends BaseController {
             throw new Error('Failed to create On Chain triggers');
         }
         finally {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+            this.#setIsUpdatingMetamaskNotifications(false);
         }
     }
     /**
@@ -649,8 +743,8 @@ export class NotificationServicesController extends BaseController {
      */
     async enableMetamaskNotifications(opts = {}) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_enableAuth).call(this);
+            this.#setIsUpdatingMetamaskNotifications(true);
+            await this.#enableAuth();
             await this.createOnChainTriggers(opts);
         }
         catch (error) {
@@ -658,7 +752,7 @@ export class NotificationServicesController extends BaseController {
             throw new Error('Unable to enable notifications');
         }
         finally {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+            this.#setIsUpdatingMetamaskNotifications(false);
         }
     }
     /**
@@ -670,10 +764,10 @@ export class NotificationServicesController extends BaseController {
      * @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);
+        this.#setIsUpdatingMetamaskNotifications(true);
         // Attempt Disable Push Notifications
         try {
-            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
+            await this.#pushNotifications.disablePushNotifications();
         }
         catch {
             // Do nothing
@@ -688,7 +782,7 @@ export class NotificationServicesController extends BaseController {
             state.metamaskNotificationsList = snapNotifications;
         });
         // Finish Updating State
-        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+        this.#setIsUpdatingMetamaskNotifications(false);
     }
     /**
      * Deletes on-chain triggers associated with a specific account/s.
@@ -705,16 +799,16 @@ export class NotificationServicesController extends BaseController {
      */
     async disableAccounts(accounts) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: false })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
-            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").deletePushNotificationLinks(accounts);
+            this.#updateUpdatingAccountsState(accounts);
+            const { bearerToken } = await this.#getBearerToken();
+            await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: false })), this.#env);
+            await this.#pushNotifications.deletePushNotificationLinks(accounts);
         }
         catch {
             throw new Error('Failed to delete OnChain triggers');
         }
         finally {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_clearUpdatingAccountsState).call(this, accounts);
+            this.#clearUpdatingAccountsState(accounts);
         }
     }
     /**
@@ -734,17 +828,17 @@ export class NotificationServicesController extends BaseController {
      */
     async enableAccounts(accounts) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: true })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
-            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").addPushNotificationLinks(accounts);
+            this.#updateUpdatingAccountsState(accounts);
+            const { bearerToken } = await this.#getBearerToken();
+            await updateOnChainNotifications(bearerToken, accounts.map((address) => ({ address, enabled: true })), this.#env);
+            await this.#pushNotifications.addPushNotificationLinks(accounts);
         }
         catch (error) {
             log.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);
+            this.#clearUpdatingAccountsState(accounts);
         }
     }
     /**
@@ -759,7 +853,7 @@ export class NotificationServicesController extends BaseController {
      */
     async fetchAndUpdateMetamaskNotifications(previewToken) {
         try {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, true);
+            this.#setIsFetchingMetamaskNotifications(true);
             // This is used by Feature Announcement & On Chain
             // Not used by Snaps
             const isGlobalNotifsEnabled = this.state.isNotificationServicesEnabled;
@@ -771,20 +865,20 @@ export class NotificationServicesController extends BaseController {
             // Raw Feature Notifications
             const rawAnnouncements = isGlobalNotifsEnabled &&
                 notificationPreferences?.marketing.inAppNotificationsEnabled
-                ? await getFeatureAnnouncementNotifications(__classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f"), previewToken).catch(() => [])
+                ? await getFeatureAnnouncementNotifications(this.#featureAnnouncementEnv, previewToken).catch(() => [])
                 : [];
             // Raw On Chain Notifications
             const rawOnChainNotifications = [];
             if (isGlobalNotifsEnabled) {
                 try {
-                    const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+                    const { bearerToken } = await this.#getBearerToken();
                     // Addresses come from the keyring, so this installation can only ever
                     // ask for activity on accounts it actually holds. The Trigger API
                     // narrows that to the ones the user has enabled.
-                    const { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
-                    const addressesWithNotifications = await getEnabledAccounts(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+                    const { accounts } = this.#accounts.listAccounts();
+                    const addressesWithNotifications = await getEnabledAccounts(bearerToken, accounts, this.#env);
                     if (addressesWithNotifications !== null) {
-                        const notifications = await getAPINotifications(bearerToken, addressesWithNotifications, __classPrivateFieldGet(this, _NotificationServicesController_locale, "f").call(this), __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => []);
+                        const notifications = await getAPINotifications(bearerToken, addressesWithNotifications, this.#locale(), this.#featureAnnouncementEnv.platform, this.#env).catch(() => []);
                         rawOnChainNotifications.push(...notifications);
                     }
                 }
@@ -810,11 +904,11 @@ export class NotificationServicesController extends BaseController {
                 state.metamaskNotificationsList = metamaskNotifications;
             });
             this.messenger.publish(`${controllerName}:notificationsListUpdated`, this.state.metamaskNotificationsList);
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            this.#setIsFetchingMetamaskNotifications(false);
             return metamaskNotifications;
         }
         catch (error) {
-            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            this.#setIsFetchingMetamaskNotifications(false);
             log.error('Failed to fetch notifications', error);
             throw new Error('Failed to fetch notifications');
         }
@@ -893,10 +987,10 @@ export class NotificationServicesController extends BaseController {
             }, [[], [], []]);
             // Mark On-Chain Notifications as Read
             if (onChainNotifications.length > 0) {
-                const bearerToken = await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").getBearerToken();
+                const bearerToken = await this.#auth.getBearerToken();
                 if (bearerToken) {
                     onchainNotificationIds = onChainNotifications.map((notification) => notification.id);
-                    await markNotificationsAsRead(bearerToken, onchainNotificationIds, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => {
+                    await markNotificationsAsRead(bearerToken, onchainNotificationIds, this.#env).catch(() => {
                         onchainNotificationIds = [];
                         log.warn('Unable to mark onchain notifications as read');
                     });
@@ -975,7 +1069,7 @@ export class NotificationServicesController extends BaseController {
      */
     async sendPerpPlaceOrderNotification(input) {
         try {
-            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            const { bearerToken } = await this.#getBearerToken();
             await createPerpOrderNotification(bearerToken, input);
         }
         catch {
@@ -983,73 +1077,4 @@ export class NotificationServicesController extends BaseController {
         }
     }
 }
-_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_registerPushNotifications = 
-/**
- * Registers this device for push notifications on the given addresses.
- *
- * An empty list cannot be sent: the push API rejects a registration with no
- * addresses, and because that request is what performs the delete-and-reinsert
- * of the device's links, a rejection leaves the previous links in place and
- * push keeps arriving. So "no addresses" has to mean unregistering the device.
- *
- * @param addresses - The addresses to receive push notifications for.
- */
-async function _NotificationServicesController_registerPushNotifications(addresses) {
-    if (addresses.length === 0) {
-        await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
-        return;
-    }
-    await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(addresses);
-}, _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.mjs.map
+//# sourceMappingURL=NotificationServicesController.js.map