@metamask-previews/notification-services-controller 26.0.1-preview-6ed11f88f → 27.0.0-preview-2d576f0c9

package/CHANGELOG.md

@@ -7,10 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [27.0.0]
+
 ### Changed
 
+- **BREAKING:** `getNotificationsApiConfigCached` now returns `null` when the Trigger API could not be read, and an empty array only when the API reported that no address is subscribed ([#9985](https://github.com/MetaMask/core/pull/9985))
+  - Previously both cases returned an empty array, so callers could not tell "the user has nothing enabled" from "we failed to ask", and acting on the guess re-subscribed or unregistered addresses behind the user.
 - Bump `@metamask/keyring-controller` from `^27.1.0` to `^27.1.1` ([#9791](https://github.com/MetaMask/core/pull/9791))
 - Bump `@metamask/authenticated-user-storage` from `^3.0.1` to `^3.0.2` ([#9972](https://github.com/MetaMask/core/pull/9972))
+- Bump `@metamask/utils` from `^11.11.0` to `^11.12.0` ([#10076](https://github.com/MetaMask/core/pull/10076))
+
+### Fixed
+
+- **BREAKING:** Wallet-activity addresses are once again sourced from the keyring and the Trigger API instead of Authenticated User Storage, which stops users receiving notifications for addresses they do not hold ([#9985](https://github.com/MetaMask/core/pull/9985))
+  - Authenticated User Storage is keyed by canonical profile ID, which profile pairing shares across every SRP belonging to the same user, so an address list stored there pooled the addresses of unrelated SRPs and delivered each installation the union of all of them. Addresses are keyring-scoped and cannot live in profile-scoped storage.
+  - `checkAccountsPresence`, `fetchAndUpdateMetamaskNotifications` and `enablePushNotifications` now take the candidate addresses from the keyring and read the per-address enabled bit from the Trigger API. An installation can therefore only ever ask about addresses it holds.
+  - `enableAccounts` and `disableAccounts` now write subscriptions to the Trigger API. The endpoint is a per-address upsert, so two installations authenticating as the same profile no longer clobber each other's subscriptions.
+  - `createOnChainTriggers` no longer writes addresses into `walletActivity.accounts`; it writes an empty list. It subscribes the keyring's accounts only when initializing preferences for the first time and the Trigger API has no subscriptions yet, so the daily re-subscribe can no longer re-enable accounts the user turned off.
+  - The user-level `walletActivity.inAppNotificationsEnabled` and `walletActivity.pushNotificationsEnabled` toggles are still read from Authenticated User Storage. They contain no addresses, so they remain correct to share across a paired profile. An unreadable preferences blob is treated as both toggles enabled, so a storage outage no longer empties the notification list.
+- Unregister the device from push notifications when no account has notifications enabled ([#9985](https://github.com/MetaMask/core/pull/9985))
+  - The push API rejects a registration with no addresses, and that request is what performs the delete-and-reinsert of the device's links, so the rejection left the previous links in place and push kept arriving after a user disabled every account.
+- `enableAccounts` and `disableAccounts` now reject when the Trigger API rejects the subscription change, instead of reporting success and caching a state the server never applied ([#9985](https://github.com/MetaMask/core/pull/9985))
+  - A 4xx/5xx response was treated as success, so the settings UI showed the new toggle position and push links were added or removed for a subscription that did not change.
+- A failed Trigger API config read no longer re-enables accounts or unregisters the device ([#9985](https://github.com/MetaMask/core/pull/9985))
+  - `createOnChainTriggers` now fails instead of reading a failed config query as "no subscriptions yet", which could subscribe every keyring account for a user who had turned them off, and it writes the preferences blob only after those subscriptions are in place so a failed run can still be retried as a first-time setup.
+  - `enablePushNotifications` leaves the device's existing push links alone rather than unregistering it, and `checkAccountsPresence` rejects rather than reporting every account as disabled.
 
 ## [26.0.1]
 
@@ -856,7 +877,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@26.0.1...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@27.0.0...HEAD
+[27.0.0]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@26.0.1...@metamask/notification-services-controller@27.0.0
 [26.0.1]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@26.0.0...@metamask/notification-services-controller@26.0.1
 [26.0.0]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@25.0.0...@metamask/notification-services-controller@26.0.0
 [25.0.0]: https://github.com/MetaMask/core/compare/@metamask/notification-services-controller@24.3.0...@metamask/notification-services-controller@25.0.0

package/dist/NotificationServicesController/NotificationServicesController.cjs

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _NotificationServicesController_instances, _NotificationServicesController_keyringController, _NotificationServicesController_auth, _NotificationServicesController_pushNotifications, _NotificationServicesController_accounts, _NotificationServicesController_locale, _NotificationServicesController_featureAnnouncementEnv, _NotificationServicesController_env, _NotificationServicesController_clearLoadingStates, _NotificationServicesController_assertAuthEnabled, _NotificationServicesController_enableAuth, _NotificationServicesController_getBearerToken, _NotificationServicesController_registerWalletActivityAddresses, _NotificationServicesController_setIsUpdatingMetamaskNotifications, _NotificationServicesController_setIsFetchingMetamaskNotifications, _NotificationServicesController_setIsCheckingAccountsPresence, _NotificationServicesController_updateUpdatingAccountsState, _NotificationServicesController_clearUpdatingAccountsState;
+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_isWalletActivityPushEnabled, _NotificationServicesController_registerPushNotifications, _NotificationServicesController_setIsUpdatingMetamaskNotifications, _NotificationServicesController_setIsFetchingMetamaskNotifications, _NotificationServicesController_setIsCheckingAccountsPresence, _NotificationServicesController_updateUpdatingAccountsState, _NotificationServicesController_clearUpdatingAccountsState;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationServicesController = exports.DEFAULT_PRICE_ALERT_PREFERENCES = exports.DEFAULT_AGENTIC_CLI_PREFERENCES = exports.DEFAULT_SOCIAL_AI_PREFERENCES = exports.DEFAULT_PERPS_PREFERENCES = exports.defaultState = exports.ACCOUNTS_UPDATE_DEBOUNCE_TIME_MS = void 0;
 const authenticated_user_storage_1 = require("@metamask/authenticated-user-storage");
@@ -129,57 +129,46 @@ var authenticated_user_storage_2 = require("@metamask/authenticated-user-storage
 Object.defineProperty(exports, "DEFAULT_AGENTIC_CLI_PREFERENCES", { enumerable: true, get: function () { return authenticated_user_storage_2.DEFAULT_AGENTIC_CLI_PREFERENCES; } });
 Object.defineProperty(exports, "DEFAULT_PRICE_ALERT_PREFERENCES", { enumerable: true, get: function () { return authenticated_user_storage_2.DEFAULT_PRICE_ALERT_PREFERENCES; } });
 /**
- * Builds wallet-activity preferences from the keyring's current accounts.
+ * 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.
  *
- * @param accounts - The keyring accounts to build wallet-activity entries for.
- * @returns An array of wallet-activity account entries (lower-cased addresses).
- */
-const buildWalletActivityAccounts = (accounts) => accounts.map(({ address, enabled }) => {
-    const lowercased = address.toLowerCase();
-    return {
-        address: lowercased,
-        enabled,
-    };
-});
-/**
- * Builds wallet-activity initialization from the Trigger API. If Trigger has no
- * enabled entries for the current keyring accounts, this is a first-time
- * notification setup and all current accounts should start enabled.
+ * The address universe is always supplied by the caller from the keyring, so the
+ * result cannot contain an address this installation does not hold.
  *
- * @param bearerToken - JWT used to query Trigger API.
- * @param accounts - The keyring accounts to initialize.
+ * @param bearerToken - JWT used to query the Trigger API.
+ * @param accounts - The keyring accounts to check.
  * @param env - The environment to use for the Trigger API call.
- * @returns Wallet-activity account initialization entries.
+ * @returns The enabled addresses, as returned by the Trigger API, or `null` if
+ * the Trigger API could not be read.
  */
-const buildWalletActivityAccountsFromTriggerConfig = async (bearerToken, accounts, env) => {
+const getEnabledAccounts = async (bearerToken, accounts, env) => {
     const triggerConfig = await (0, api_notifications_js_1.getNotificationsApiConfigCached)(bearerToken, accounts, env);
-    const triggerConfigByAddress = new Map(triggerConfig.map(({ address, enabled }) => [
-        address.toLowerCase(),
-        enabled,
-    ]));
-    const hasEnabledTriggerAccount = accounts.some((address) => triggerConfigByAddress.get(address.toLowerCase()) === true);
-    return accounts.map((address) => ({
-        address,
-        enabled: hasEnabledTriggerAccount
-            ? (triggerConfigByAddress.get(address.toLowerCase()) ?? false)
-            : true,
-    }));
+    if (triggerConfig === null) {
+        return null;
+    }
+    return triggerConfig
+        .filter((addressConfig) => Boolean(addressConfig.enabled))
+        .map((addressConfig) => addressConfig.address);
 };
 /**
  * Builds a fresh `NotificationPreferences` blob using hardcoded defaults for
- * Perps, Social AI, and Agentic CLI, the supplied wallet-activity accounts and
- * the user's marketing/product-announcement flags.
+ * Perps, Social AI, and Agentic CLI and the user's marketing/product-announcement
+ * flags.
+ *
+ * `walletActivity.accounts` is deliberately left empty. Addresses are scoped to a
+ * keyring, but this blob is keyed by canonical profile ID, which pairing shares
+ * across every SRP belonging to the same user — so storing them here pools the
+ * addresses of unrelated SRPs. Subscriptions live in the Trigger API instead.
  *
- * @param walletActivityAccounts - The wallet-activity account config to initialize.
  * @param hasMarketingConsent - Whether marketing push notifications should be enabled.
  * @param productAnnouncementEnabled - Whether marketing in-app notifications should be enabled.
  * @returns A complete `NotificationPreferences` object.
  */
-const buildFreshPreferences = (walletActivityAccounts, hasMarketingConsent, productAnnouncementEnabled) => ({
+const buildFreshPreferences = (hasMarketingConsent, productAnnouncementEnabled) => ({
     walletActivity: {
         inAppNotificationsEnabled: true,
         pushNotificationsEnabled: true,
-        accounts: buildWalletActivityAccounts(walletActivityAccounts),
+        accounts: [],
     },
     marketing: {
         inAppNotificationsEnabled: productAnnouncementEnabled,
@@ -481,13 +470,20 @@ class NotificationServicesController extends base_controller_1.BaseController {
      */
     async enablePushNotifications() {
         try {
-            const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
-            const enabledAddresses = (preferences?.walletActivity.accounts ?? [])
-                .filter((account) => account.enabled)
-                .map((account) => account.address);
-            if (enabledAddresses.length > 0) {
-                await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(enabledAddresses);
+            if (!(await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_isWalletActivityPushEnabled).call(this))) {
+                await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").disablePushNotifications();
+                return;
             }
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            const { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
+            const enabledAddresses = await getEnabledAccounts(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+            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);
         }
         catch {
             // Do nothing, failing silently.
@@ -502,10 +498,16 @@ class NotificationServicesController extends base_controller_1.BaseController {
     async checkAccountsPresence(accounts) {
         try {
             __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsCheckingAccountsPresence).call(this, true);
-            const preferences = await this.messenger.call('AuthenticatedUserStorageService:getNotificationPreferences');
-            const enabledByAddress = new Map((preferences?.walletActivity.accounts ?? []).map((account) => [
-                account.address.toLowerCase(),
-                account.enabled,
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            const triggerConfig = await (0, api_notifications_js_1.getNotificationsApiConfigCached)(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+            if (triggerConfig === null) {
+                // Reporting every account as disabled would misrepresent the user's
+                // settings, so surface the failure instead.
+                throw new Error('Failed to read wallet-activity subscriptions');
+            }
+            const enabledByAddress = new Map(triggerConfig.map((addressConfig) => [
+                addressConfig.address.toLowerCase(),
+                Boolean(addressConfig.enabled),
             ]));
             const result = {};
             for (const address of accounts) {
@@ -564,27 +566,48 @@ class NotificationServicesController extends base_controller_1.BaseController {
             __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_setIsUpdatingMetamaskNotifications).call(this, true);
             const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
             const { accounts } = __classPrivateFieldGet(this, _NotificationServicesController_accounts, "f").listAccounts();
-            // 1. Read existing AUS notification preferences and initialize only if absent.
+            // 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');
             const hasMarketingConsent = Boolean(opts?.hasMarketingConsent);
             const productAnnouncementEnabled = Boolean(opts?.productAnnouncementEnabled);
-            let nextPreferences;
-            if (preferences === null) {
-                const walletActivityAccounts = await buildWalletActivityAccountsFromTriggerConfig(bearerToken, accounts, __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
-                nextPreferences = buildFreshPreferences(walletActivityAccounts, hasMarketingConsent, productAnnouncementEnabled);
+            const isFirstTimeSetup = preferences === null;
+            const isPushEnabled = preferences?.walletActivity.pushNotificationsEnabled ?? true;
+            // 2. Subscribe the keyring's accounts on first-time setup only.
+            //
+            // This method also runs on the daily re-subscribe, so the absence of a
+            // preferences blob — not the absence of subscriptions — is what marks a
+            // genuine first-time setup. Keying off "no subscriptions" would re-enable
+            // every account daily for a user who had turned them all off.
+            //
+            // 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"));
+            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
+                // registering push for that guessed list would send activity for them,
+                // so fail and let the caller retry.
+                throw new Error('Failed to read wallet-activity subscriptions');
+            }
+            if (isFirstTimeSetup && accountsWithNotifications.length === 0) {
+                await (0, api_notifications_js_1.updateOnChainNotifications)(bearerToken, accounts.map((address) => ({ address, enabled: true })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
+                // 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());
             }
-            if (nextPreferences) {
-                await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', nextPreferences, __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform);
+            // 3. Initialize the preferences blob, only once the subscriptions above
+            // are in place. Its existence is what makes the next run a re-subscribe
+            // rather than a first-time setup, so writing it earlier would let a
+            // 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);
             }
-            const effectivePreferences = nextPreferences ?? preferences;
-            const accountsWithNotifications = (effectivePreferences?.walletActivity.accounts ?? [])
-                .filter((account) => account.enabled)
-                .map((account) => account.address);
             if (opts.registerPushNotifications ?? true) {
                 // Attempt FCM/device registration only; clients must request OS permission separately.
-                __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f")
-                    .enablePushNotifications(accountsWithNotifications)
-                    .catch(() => {
+                __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerPushNotifications).call(this, isPushEnabled ? accountsWithNotifications : []).catch(() => {
                     // Do Nothing
                 });
             }
@@ -677,9 +700,8 @@ class NotificationServicesController extends base_controller_1.BaseController {
     async disableAccounts(accounts) {
         try {
             __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
-            // Sign-in gate.
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerWalletActivityAddresses).call(this, accounts.map((address) => ({ address, enabled: false })));
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            await (0, api_notifications_js_1.updateOnChainNotifications)(bearerToken, accounts.map((address) => ({ address, enabled: false })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
             await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").deletePushNotificationLinks(accounts);
         }
         catch {
@@ -707,9 +729,8 @@ class NotificationServicesController extends base_controller_1.BaseController {
     async enableAccounts(accounts) {
         try {
             __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_updateUpdatingAccountsState).call(this, accounts);
-            // Sign-in gate.
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-            await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_registerWalletActivityAddresses).call(this, accounts.map((address) => ({ address, enabled: true })));
+            const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
+            await (0, api_notifications_js_1.updateOnChainNotifications)(bearerToken, accounts.map((address) => ({ address, enabled: true })), __classPrivateFieldGet(this, _NotificationServicesController_env, "f"));
             await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").addPushNotificationLinks(accounts);
         }
         catch (error) {
@@ -748,14 +769,20 @@ class NotificationServicesController extends base_controller_1.BaseController {
                 : [];
             // Raw On Chain Notifications
             const rawOnChainNotifications = [];
-            if (isGlobalNotifsEnabled) {
+            const isWalletActivityInAppEnabled = notificationPreferences?.walletActivity.inAppNotificationsEnabled ??
+                true;
+            if (isGlobalNotifsEnabled && isWalletActivityInAppEnabled) {
                 try {
                     const { bearerToken } = await __classPrivateFieldGet(this, _NotificationServicesController_instances, "m", _NotificationServicesController_getBearerToken).call(this);
-                    const addressesWithNotifications = (notificationPreferences?.walletActivity.accounts ?? [])
-                        .filter((account) => account.enabled)
-                        .map((account) => account.address);
-                    const notifications = await (0, api_notifications_js_1.getAPINotifications)(bearerToken, addressesWithNotifications, __classPrivateFieldGet(this, _NotificationServicesController_locale, "f").call(this), __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => []);
-                    rawOnChainNotifications.push(...notifications);
+                    // 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"));
+                    if (addressesWithNotifications !== null) {
+                        const notifications = await (0, api_notifications_js_1.getAPINotifications)(bearerToken, addressesWithNotifications, __classPrivateFieldGet(this, _NotificationServicesController_locale, "f").call(this), __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform, __classPrivateFieldGet(this, _NotificationServicesController_env, "f")).catch(() => []);
+                        rawOnChainNotifications.push(...notifications);
+                    }
                 }
                 catch {
                     // Do nothing
@@ -979,53 +1006,44 @@ _NotificationServicesController_keyringController = new WeakMap(), _Notification
         throw new Error('Missing BearerToken');
     }
     return { bearerToken };
-}, _NotificationServicesController_registerWalletActivityAddresses = 
+}, _NotificationServicesController_isWalletActivityPushEnabled = 
 /**
- * Updates the `walletActivity.accounts` entries in the user's
- * notification-preferences blob in {@link AuthenticatedUserStorageService}.
+ * Reads the global wallet-activity push toggle from
+ * {@link AuthenticatedUserStorageService}.
+ *
+ * Only the channel boolean is read. It is a user-level setting that contains
+ * no addresses, so sharing it across a paired profile is correct. The address
+ * list in the same blob is deliberately ignored — see
+ * {@link buildFreshPreferences}.
  *
- * `putNotificationPreferences` replaces the entire blob, so we read the
- * current preferences, merge the supplied updates into
- * `walletActivity.accounts`, and write the result back. This helper is only
- * meant to be used for incremental updates (enable/disable individual
- * accounts) after the preferences blob has already been initialized via
- * {@link createOnChainTriggers}; callers should not rely on it to perform
- * first-time initialization.
+ * A missing or unreadable blob counts as enabled, matching the API's "every
+ * toggle is on unless stated otherwise" default, so that a storage outage does
+ * not silently stop notifications.
  *
- * @param updates - Addresses to register, each with the desired `enabled` flag
+ * @returns Whether wallet-activity push notifications are enabled.
  */
-async function _NotificationServicesController_registerWalletActivityAddresses(updates) {
-    if (updates.length === 0) {
-        return;
-    }
-    const currentPreferences = await this.messenger
+async function _NotificationServicesController_isWalletActivityPushEnabled() {
+    const preferences = await this.messenger
         .call('AuthenticatedUserStorageService:getNotificationPreferences')
-        .catch((error) => {
-        loglevel_1.default.error('Failed to get notification preferences. Re-initializing them instead.', error);
-        // TODO: return null once validation error captured
-        // return null;
-        throw error;
-    });
-    if (!currentPreferences) {
-        loglevel_1.default.warn('Preferences blob not yet initialized; run `createOnChainTriggers` first.');
+        .catch(() => null);
+    return preferences?.walletActivity.pushNotificationsEnabled ?? true;
+}, _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;
     }
-    const accountsByAddress = new Map(currentPreferences.walletActivity.accounts.map((account) => [
-        account.address.toLowerCase(),
-        { ...account, address: account.address.toLowerCase() },
-    ]));
-    for (const update of updates) {
-        const address = update.address.toLowerCase();
-        accountsByAddress.set(address, { address, enabled: update.enabled });
-    }
-    const nextPreferences = {
-        ...currentPreferences,
-        walletActivity: {
-            ...currentPreferences.walletActivity,
-            accounts: [...accountsByAddress.values()],
-        },
-    };
-    await this.messenger.call('AuthenticatedUserStorageService:putNotificationPreferences', nextPreferences, __classPrivateFieldGet(this, _NotificationServicesController_featureAnnouncementEnv, "f").platform);
+    await __classPrivateFieldGet(this, _NotificationServicesController_pushNotifications, "f").enablePushNotifications(addresses);
 }, _NotificationServicesController_setIsUpdatingMetamaskNotifications = function _NotificationServicesController_setIsUpdatingMetamaskNotifications(isUpdatingMetamaskNotifications) {
     this.update((state) => {
         state.isUpdatingMetamaskNotifications = isUpdatingMetamaskNotifications;