@metamask-previews/notification-services-controller 0.5.0-preview-9edcf0e0 → 0.5.0-preview-9d310688

package/dist/NotificationServicesController/NotificationServicesController.mjs

@@ -1,19 +1,781 @@
-import {
-  NotificationServicesController,
-  defaultState
-} from "../chunk-WE4RFGT7.mjs";
-import "../chunk-MG5QDUDI.mjs";
-import "../chunk-BONB66A2.mjs";
-import "../chunk-C62SK2KY.mjs";
-import "../chunk-D42BBXBM.mjs";
-import "../chunk-OHFX4S6R.mjs";
-import "../chunk-YUMIJSUD.mjs";
-import "../chunk-53F3SYYM.mjs";
-import "../chunk-DINCLRZT.mjs";
-import "../chunk-6ZDVTRRT.mjs";
-import "../chunk-U5UIDVOO.mjs";
-export {
-  NotificationServicesController as default,
-  defaultState
+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_isPushIntegrated, _NotificationServicesController_isPushNotificationsSetup, _NotificationServicesController_isUnlocked, _NotificationServicesController_keyringController, _NotificationServicesController_auth, _NotificationServicesController_storage, _NotificationServicesController_pushNotifications, _NotificationServicesController_accounts, _NotificationServicesController_featureAnnouncementEnv, _NotificationServicesController_registerMessageHandlers, _NotificationServicesController_clearLoadingStates, _NotificationServicesController_assertAuthEnabled, _NotificationServicesController_getValidStorageKeyAndBearerToken, _NotificationServicesController_performEnableProfileSyncing, _NotificationServicesController_assertUserStorage, _NotificationServicesController_getUserStorage, _NotificationServicesController_setIsUpdatingMetamaskNotifications, _NotificationServicesController_setIsFetchingMetamaskNotifications, _NotificationServicesController_setIsCheckingAccountsPresence, _NotificationServicesController_updateUpdatingAccountsState, _NotificationServicesController_clearUpdatingAccountsState;
+function $importDefault(module) {
+    if (module?.__esModule) {
+        return module.default;
+    }
+    return module;
+}
+import { BaseController } from "@metamask/base-controller";
+import { toChecksumHexAddress } from "@metamask/controller-utils";
+import $log from "loglevel";
+const log = $importDefault($log);
+import { USER_STORAGE_VERSION_KEY } from "./constants/constants.mjs";
+import { TRIGGER_TYPES } from "./constants/notification-schema.mjs";
+import { safeProcessNotification } from "./processors/process-notifications.mjs";
+import * as FeatureNotifications from "./services/feature-announcements.mjs";
+import * as OnChainNotifications from "./services/onchain-notifications.mjs";
+import * as Utils from "./utils/utils.mjs";
+// Unique name for the controller
+const controllerName = 'NotificationServicesController';
+const metadata = {
+    subscriptionAccountsSeen: {
+        persist: true,
+        anonymous: true,
+    },
+    isMetamaskNotificationsFeatureSeen: {
+        persist: true,
+        anonymous: false,
+    },
+    isNotificationServicesEnabled: {
+        persist: true,
+        anonymous: false,
+    },
+    isFeatureAnnouncementsEnabled: {
+        persist: true,
+        anonymous: false,
+    },
+    metamaskNotificationsList: {
+        persist: true,
+        anonymous: true,
+    },
+    metamaskNotificationsReadList: {
+        persist: true,
+        anonymous: true,
+    },
+    isUpdatingMetamaskNotifications: {
+        persist: false,
+        anonymous: false,
+    },
+    isFetchingMetamaskNotifications: {
+        persist: false,
+        anonymous: false,
+    },
+    isUpdatingMetamaskNotificationsAccount: {
+        persist: false,
+        anonymous: false,
+    },
+    isCheckingAccountsPresence: {
+        persist: false,
+        anonymous: false,
+    },
+};
+export const defaultState = {
+    subscriptionAccountsSeen: [],
+    isMetamaskNotificationsFeatureSeen: false,
+    isNotificationServicesEnabled: false,
+    isFeatureAnnouncementsEnabled: false,
+    metamaskNotificationsList: [],
+    metamaskNotificationsReadList: [],
+    isUpdatingMetamaskNotifications: false,
+    isFetchingMetamaskNotifications: false,
+    isUpdatingMetamaskNotificationsAccount: [],
+    isCheckingAccountsPresence: false,
+};
+/**
+ * Controller that enables wallet notifications and feature announcements
+ */
+class NotificationServicesController extends 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.isPushIntegrated - toggle push notifications on/off if client has integrated them.
+     */
+    constructor({ messenger, state, env, }) {
+        super({
+            messenger,
+            metadata,
+            name: controllerName,
+            state: { ...defaultState, ...state },
+        });
+        _NotificationServicesController_instances.add(this);
+        // Temporary boolean as push notifications are not yet enabled on mobile
+        _NotificationServicesController_isPushIntegrated.set(this, true);
+        // 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
+        _NotificationServicesController_isPushNotificationsSetup.set(this, false);
+        _NotificationServicesController_isUnlocked.set(this, false);
+        _NotificationServicesController_keyringController.set(this, {
+            setupLockedStateSubscriptions: (onUnlock) => {
+                const { isUnlocked } = this.messagingSystem.call('KeyringController:getState');
+                __classPrivateFieldSet(this, _NotificationServicesController_isUnlocked, isUnlocked, "f");
+                this.messagingSystem.subscribe('KeyringController:unlock', () => {
+                    __classPrivateFieldSet(this, _NotificationServicesController_isUnlocked, true, "f");
+                    // 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.messagingSystem.subscribe('KeyringController:lock', () => {
+                    __classPrivateFieldSet(this, _NotificationServicesController_isUnlocked, false, "f");
+                });
+            },
+        });
+        _NotificationServicesController_auth.set(this, {
+            getBearerToken: async () => {
+                return await this.messagingSystem.call('AuthenticationController:getBearerToken');
+            },
+            isSignedIn: () => {
+                return this.messagingSystem.call('AuthenticationController:isSignedIn');
+            },
+        });
+        _NotificationServicesController_storage.set(this, {
+            enableProfileSyncing: async () => {
+                return await this.messagingSystem.call('UserStorageController:enableProfileSyncing');
+            },
+            getStorageKey: () => {
+                return this.messagingSystem.call('UserStorageController:getStorageKey');
+            },
+            getNotificationStorage: async () => {
+                return await this.messagingSystem.call('UserStorageController:performGetStorage', 'notifications.notificationSettings');
+            },
+            setNotificationStorage: async (state) => {
+                return await this.messagingSystem.call('UserStorageController:performSetStorage', 'notifications.notificationSettings', state);
+            },
+        });
+        _NotificationServicesController_pushNotifications.set(this, {
+            subscribeToPushNotifications: async () => {
+                await this.messagingSystem.call('NotificationServicesPushController:subscribeToPushNotifications');
+            },
+            enablePushNotifications: async (UUIDs) => {
+                if (!__classPrivateFieldGet(this, _NotificationServicesController_isPushIntegrated, "f")) {
+                    return;
+                }
+                try {
+                    await this.messagingSystem.call('NotificationServicesPushController:enablePushNotifications', UUIDs);
+                }
+                catch (e) {
+                    log.error('Silently failed to enable push notifications', e);
+                }
+            },
+            disablePushNotifications: async (UUIDs) => {
+                if (!__classPrivateFieldGet(this, _NotificationServicesController_isPushIntegrated, "f")) {
+                    return;
+                }
+                try {
+                    await this.messagingSystem.call('NotificationServicesPushController:disablePushNotifications', UUIDs);
+                }
+                catch (e) {
+                    log.error('Silently failed to disable push notifications', e);
+                }
+            },
+            updatePushNotifications: async (UUIDs) => {
+                if (!__classPrivateFieldGet(this, _NotificationServicesController_isPushIntegrated, "f")) {
+                    return;
+                }
+                try {
+                    await this.messagingSystem.call('NotificationServicesPushController:updateTriggerPushNotifications', UUIDs);
+                }
+                catch (e) {
+                    log.error('Silently failed to update push notifications', e);
+                }
+            },
+            subscribe: () => {
+                if (!__classPrivateFieldGet(this, _NotificationServicesController_isPushIntegrated, "f")) {
+                    return;
+                }
+                this.messagingSystem.subscribe('NotificationServicesPushController:onNewNotifications', (notification) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    this.updateMetamaskNotificationsList(notification);
+                });
+            },
+            initializePushNotifications: async () => {
+                if (!__classPrivateFieldGet(this, _NotificationServicesController_isPushIntegrated, "f")) {
+                    return;
+                }
+                if (!this.state.isNotificationServicesEnabled) {
+                    return;
+                }
+                if (__classPrivateFieldGet(this, _NotificationServicesController_isPushNotificationsSetup, "f")) {
+                    return;
+                }
+                // If wallet is unlocked, we can create a fresh push subscription
+                // Otherwise we can subscribe to original subscription
+                if (__classPrivateFieldGet(this, _NotificationServicesController_isUnlocked, "f")) {
+                    const storage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+                    if (!storage) {
+                        return;
+                    }
+                    const uuids = Utils.getAllUUIDs(storage);
+                    await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(uuids);
+                    __classPrivateFieldSet(this, _NotificationServicesController_isPushNotificationsSetup, true, "f");
+                }
+                else {
+                    await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").subscribeToPushNotifications();
+                }
+            },
+        });
+        _NotificationServicesController_accounts.set(this, {
+            /**
+             * Used to get list of addresses from keyring (wallet addresses)
+             *
+             * @returns addresses removed, added, and latest list of addresses
+             */
+            listAccounts: async () => {
+                // Get previous and current account sets
+                const nonChecksumAccounts = await this.messagingSystem.call('KeyringController:getAccounts');
+                const accounts = nonChecksumAccounts.map((a) => toChecksumHexAddress(a));
+                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((a) => !prevAccountsSet.has(a));
+                const accountsRemoved = [...prevAccountsSet.values()].filter((a) => !currentAccountsSet.has(a));
+                // Update accounts seen
+                this.update((state) => {
+                    state.subscriptionAccountsSeen = [...prevAccountsSet, ...accountsAdded];
+                });
+                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.
+             *
+             * @returns result from list accounts
+             */
+            initialize: () => {
+                return __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+            },
+            /**
+             * 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: () => {
+                this.messagingSystem.subscribe('KeyringController:stateChange', 
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                async () => {
+                    if (!this.state.isNotificationServicesEnabled) {
+                        return;
+                    }
+                    const { accountsAdded, accountsRemoved } = await __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+                    const promises = [];
+                    if (accountsAdded.length > 0) {
+                        promises.push(this.updateOnChainTriggersByAccount(accountsAdded));
+                    }
+                    if (accountsRemoved.length > 0) {
+                        promises.push(this.deleteOnChainTriggersByAccount(accountsRemoved));
+                    }
+                    await Promise.all(promises);
+                });
+            },
+        });
+        _NotificationServicesController_featureAnnouncementEnv.set(this, void 0);
+        _NotificationServicesController_performEnableProfileSyncing.set(this, async () => {
+            try {
+                await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").enableProfileSyncing();
+            }
+            catch (e) {
+                log.error('Failed to enable profile syncing', e);
+                throw new Error('Failed to enable profile syncing');
+            }
+        });
+        __classPrivateFieldSet(this, _NotificationServicesController_isPushIntegrated, env.isPushIntegrated ?? true, "f");
+        __classPrivateFieldSet(this, _NotificationServicesController_featureAnnouncementEnv, env.featureAnnouncements, "f");
+        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerMessageHandlers).call(this);
+        __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_clearLoadingStates).call(this);
+        __classPrivateFieldGet(this, _NotificationServicesController_keyringController, "f").setupLockedStateSubscriptions(__classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").initializePushNotifications);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        __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();
+    }
+    /**
+     * Retrieves the current enabled state of MetaMask notifications.
+     *
+     * This method directly returns the boolean value of `isMetamaskNotificationsEnabled`
+     * from the controller's state, indicating whether MetaMask notifications are currently enabled.
+     *
+     * @returns The enabled state of MetaMask notifications.
+     */
+    selectIsNotificationServicesEnabled() {
+        return this.state.isNotificationServicesEnabled;
+    }
+    async checkAccountsPresence(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, true);
+            // Retrieve user storage
+            const userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertUserStorage).call(this, userStorage);
+            const presence = Utils.checkAccountsPresence(userStorage, accounts);
+            return presence;
+        }
+        catch (error) {
+            log.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((s) => {
+                s.isFeatureAnnouncementsEnabled = featureAnnouncementsEnabled;
+            });
+        }
+        catch (e) {
+            log.error('Unable to toggle feature announcements', e);
+            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.
+     *
+     * @returns The updated or newly created user storage.
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async createOnChainTriggers() {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+            await __classPrivateFieldGet(this, _NotificationServicesController_performEnableProfileSyncing, "f").call(this);
+            const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getValidStorageKeyAndBearerToken).call(this);
+            const { accounts } = await __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+            let userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+            // If userStorage does not exist, create a new one
+            // All the triggers created are set as: "disabled"
+            if (userStorage?.[USER_STORAGE_VERSION_KEY] === undefined) {
+                userStorage = Utils.initializeUserStorage(accounts.map((account) => ({ address: account })), false);
+                // Write the userStorage
+                await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").setNotificationStorage(JSON.stringify(userStorage));
+            }
+            // Create the triggers
+            const triggers = Utils.traverseUserStorageTriggers(userStorage);
+            await OnChainNotifications.createOnChainTriggers(userStorage, storageKey, bearerToken, triggers);
+            // Create push notifications triggers
+            const allUUIDS = Utils.getAllUUIDs(userStorage);
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(allUUIDS);
+            // Write the new userStorage (triggers are now "enabled")
+            await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").setNotificationStorage(JSON.stringify(userStorage));
+            // Update the state of the controller
+            this.update((state) => {
+                state.isNotificationServicesEnabled = true;
+                state.isFeatureAnnouncementsEnabled = true;
+                state.isMetamaskNotificationsFeatureSeen = true;
+            });
+            return userStorage;
+        }
+        catch (err) {
+            log.error('Failed to create On Chain triggers', err);
+            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.
+     * 1. Enable Profile Syncing
+     * 2. Get or Create Notification User Storage
+     * 3. Upsert Triggers
+     * 4. Update Push notifications
+     *
+     * @throws {Error} If there is an error during the process of enabling notifications.
+     */
+    async enableMetamaskNotifications() {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+            await this.createOnChainTriggers();
+        }
+        catch (e) {
+            log.error('Unable to enable notifications', e);
+            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() {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
+            // Disable Push Notifications
+            const userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertUserStorage).call(this, userStorage);
+            const UUIDs = Utils.getAllUUIDs(userStorage);
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications(UUIDs);
+            // Clear Notification States (toggles and list)
+            this.update((state) => {
+                state.isNotificationServicesEnabled = false;
+                state.isFeatureAnnouncementsEnabled = false;
+                state.metamaskNotificationsList = [];
+            });
+        }
+        catch (e) {
+            log.error('Unable to disable notifications', e);
+            throw new Error('Unable to disable notifications');
+        }
+        finally {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, false);
+        }
+    }
+    /**
+     * Deletes on-chain triggers associated with a specific account.
+     * This method performs several key operations:
+     * 1. Validates Auth & Storage
+     * 2. Finds and deletes all triggers associated with the account
+     * 3. Disables any related push notifications
+     * 4. Updates Storage to reflect new state.
+     *
+     * **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 deleteOnChainTriggersByAccount(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
+            // Get and Validate BearerToken and User Storage Key
+            const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getValidStorageKeyAndBearerToken).call(this);
+            // Get & Validate User Storage
+            const userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertUserStorage).call(this, userStorage);
+            // Get the UUIDs to delete
+            const UUIDs = accounts
+                .map((a) => Utils.getUUIDsForAccount(userStorage, a.toLowerCase()))
+                .flat();
+            if (UUIDs.length === 0) {
+                return userStorage;
+            }
+            // Delete these UUIDs (Mutates User Storage)
+            await OnChainNotifications.deleteOnChainTriggers(userStorage, storageKey, bearerToken, UUIDs);
+            // Delete these UUIDs from the push notifications
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications(UUIDs);
+            // Update User Storage
+            await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").setNotificationStorage(JSON.stringify(userStorage));
+            return userStorage;
+        }
+        catch (err) {
+            log.error('Failed to delete OnChain triggers', err);
+            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 updateOnChainTriggersByAccount(accounts) {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
+            // Get and Validate BearerToken and User Storage Key
+            const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getValidStorageKeyAndBearerToken).call(this);
+            // Get & Validate User Storage
+            const userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getUserStorage).call(this);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertUserStorage).call(this, userStorage);
+            // Add any missing triggers
+            accounts.forEach((a) => Utils.upsertAddressTriggers(a, userStorage));
+            const newTriggers = Utils.traverseUserStorageTriggers(userStorage, {
+                mapTrigger: (t) => {
+                    if (!t.enabled) {
+                        return t;
+                    }
+                    return undefined;
+                },
+            });
+            // Create any missing triggers.
+            if (newTriggers.length > 0) {
+                // Write te updated userStorage (where triggers are disabled)
+                await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").setNotificationStorage(JSON.stringify(userStorage));
+                // Create the triggers
+                const triggers = Utils.traverseUserStorageTriggers(userStorage, {
+                    mapTrigger: (t) => {
+                        if (accounts.some((a) => a.toLowerCase() === t.address.toLowerCase())) {
+                            return t;
+                        }
+                        return undefined;
+                    },
+                });
+                await OnChainNotifications.createOnChainTriggers(userStorage, storageKey, bearerToken, triggers);
+            }
+            // Update Push Notifications Triggers
+            const UUIDs = Utils.getAllUUIDs(userStorage);
+            await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").updatePushNotifications(UUIDs);
+            // Update the userStorage (where triggers are enabled)
+            await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").setNotificationStorage(JSON.stringify(userStorage));
+            return userStorage;
+        }
+        catch (err) {
+            log.error('Failed to update OnChain triggers', err);
+            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 and Feature Announcements.
+     *
+     * **Action** - When a user views the notification list page/dropdown
+     *
+     * @throws {Error} Throws an error if unauthenticated or from other operations.
+     */
+    async fetchAndUpdateMetamaskNotifications() {
+        try {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, true);
+            // Raw Feature Notifications
+            const rawFeatureAnnouncementNotifications = this.state
+                .isFeatureAnnouncementsEnabled
+                ? await FeatureNotifications.getFeatureAnnouncementNotifications(__classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f")).catch(() => [])
+                : [];
+            // Raw On Chain Notifications
+            const rawOnChainNotifications = [];
+            const userStorage = await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f")
+                .getNotificationStorage()
+                .then((s) => s && JSON.parse(s))
+                .catch(() => null);
+            const bearerToken = await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").getBearerToken().catch(() => null);
+            if (userStorage && bearerToken) {
+                const notifications = await OnChainNotifications.getOnChainNotifications(userStorage, bearerToken).catch(() => []);
+                rawOnChainNotifications.push(...notifications);
+            }
+            const readIds = this.state.metamaskNotificationsReadList;
+            // Combined Notifications
+            const isNotUndefined = (t) => Boolean(t);
+            const processAndFilter = (ns) => ns
+                .map((n) => safeProcessNotification(n, readIds))
+                .filter(isNotUndefined);
+            const featureAnnouncementNotifications = processAndFilter(rawFeatureAnnouncementNotifications);
+            const onChainNotifications = processAndFilter(rawOnChainNotifications);
+            const metamaskNotifications = [
+                ...featureAnnouncementNotifications,
+                ...onChainNotifications,
+            ];
+            metamaskNotifications.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+            // Update State
+            this.update((state) => {
+                state.metamaskNotificationsList = metamaskNotifications;
+            });
+            this.messagingSystem.publish(`${controllerName}:notificationsListUpdated`, this.state.metamaskNotificationsList);
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            return metamaskNotifications;
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsFetchingMetamaskNotifications).call(this, false);
+            log.error('Failed to fetch notifications', err);
+            throw new Error('Failed to fetch notifications');
+        }
+    }
+    /**
+     * 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 = [];
+        try {
+            // Filter unread on/off chain notifications
+            const onChainNotifications = notifications.filter((notification) => notification.type !== TRIGGER_TYPES.FEATURES_ANNOUNCEMENT &&
+                !notification.isRead);
+            const featureAnnouncementNotifications = notifications.filter((notification) => notification.type === TRIGGER_TYPES.FEATURES_ANNOUNCEMENT &&
+                !notification.isRead);
+            // 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 OnChainNotifications.markNotificationsAsRead(bearerToken, onchainNotificationIds).catch(() => {
+                        onchainNotificationIds = [];
+                        log.warn('Unable to mark onchain notifications as read');
+                    });
+                }
+            }
+            // Mark Off-Chain notifications as Read
+            if (featureAnnouncementNotifications.length > 0) {
+                featureAnnouncementNotificationIds =
+                    featureAnnouncementNotifications.map((notification) => notification.id);
+            }
+        }
+        catch (err) {
+            log.warn('Something failed when marking notifications as read', err);
+        }
+        // Update the state (state is also used on counter & badge)
+        this.update((state) => {
+            const currentReadList = state.metamaskNotificationsReadList;
+            const newReadIds = [...featureAnnouncementNotificationIds];
+            state.metamaskNotificationsReadList = [
+                ...new Set([...currentReadList, ...newReadIds]),
+            ];
+            state.metamaskNotificationsList = state.metamaskNotificationsList.map((notification) => {
+                if (newReadIds.includes(notification.id) ||
+                    onchainNotificationIds.includes(notification.id)) {
+                    return { ...notification, isRead: true };
+                }
+                return notification;
+            });
+        });
+        this.messagingSystem.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((n) => n.id === notification.id)) {
+            return;
+        }
+        const processedNotification = safeProcessNotification(notification);
+        if (processedNotification) {
+            this.update((state) => {
+                const existingNotificationIds = new Set(state.metamaskNotificationsList.map((n) => n.id));
+                // Add the new notification only if its ID is not already present in the list
+                if (!existingNotificationIds.has(notification.id)) {
+                    state.metamaskNotificationsList = [
+                        notification,
+                        ...state.metamaskNotificationsList,
+                    ];
+                    this.messagingSystem.publish(`${controllerName}:notificationsListUpdated`, state.metamaskNotificationsList);
+                }
+            });
+        }
+    }
+}
+_NotificationServicesController_isPushIntegrated = new WeakMap(), _NotificationServicesController_isPushNotificationsSetup = new WeakMap(), _NotificationServicesController_isUnlocked = new WeakMap(), _NotificationServicesController_keyringController = new WeakMap(), _NotificationServicesController_auth = new WeakMap(), _NotificationServicesController_storage = new WeakMap(), _NotificationServicesController_pushNotifications = new WeakMap(), _NotificationServicesController_accounts = new WeakMap(), _NotificationServicesController_featureAnnouncementEnv = new WeakMap(), _NotificationServicesController_performEnableProfileSyncing = new WeakMap(), _NotificationServicesController_instances = new WeakSet(), _NotificationServicesController_registerMessageHandlers = function _NotificationServicesController_registerMessageHandlers() {
+    this.messagingSystem.registerActionHandler(`${controllerName}:updateMetamaskNotificationsList`, this.updateMetamaskNotificationsList.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:disableNotificationServices`, this.disableNotificationServices.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:selectIsNotificationServicesEnabled`, this.selectIsNotificationServicesEnabled.bind(this));
+}, _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_getValidStorageKeyAndBearerToken = async function _NotificationServicesController_getValidStorageKeyAndBearerToken() {
+    __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_assertAuthEnabled).call(this);
+    const bearerToken = await __classPrivateFieldGet(this, _NotificationServicesController_auth, "f").getBearerToken();
+    const storageKey = await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").getStorageKey();
+    if (!bearerToken || !storageKey) {
+        throw new Error('Missing BearerToken or storage key');
+    }
+    return { bearerToken, storageKey };
+}, _NotificationServicesController_assertUserStorage = function _NotificationServicesController_assertUserStorage(storage) {
+    if (!storage) {
+        throw new Error('User Storage does not exist');
+    }
+}, _NotificationServicesController_getUserStorage = 
+/**
+ * Retrieves and parses the user storage from the storage key.
+ *
+ * This method attempts to retrieve the user storage using the specified storage key,
+ * then parses the JSON string to an object. If the storage is not found or cannot be parsed,
+ * it throws an error.
+ *
+ * @returns The parsed user storage object or null
+ */
+async function _NotificationServicesController_getUserStorage() {
+    const userStorageString = await __classPrivateFieldGet(this, _NotificationServicesController_storage, "f").getNotificationStorage();
+    if (!userStorageString) {
+        return null;
+    }
+    try {
+        const userStorage = JSON.parse(userStorageString);
+        return userStorage;
+    }
+    catch (error) {
+        log.error('Unable to parse User Storage');
+        return null;
+    }
+}, _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));
+    });
+};
+export default NotificationServicesController;
 //# sourceMappingURL=NotificationServicesController.mjs.map