@metamask-previews/notification-services-controller 0.0.0-preview-98d4c2a0 → 0.0.0-preview-e751859

package/dist/{chunk-KTQP5UDT.mjs → chunk-IG3CMJBW.mjs}

@@ -1,33 +1,14 @@
 import {
-  processors_exports
-} from "./chunk-QTK2RMF7.mjs";
-import {
-  types_exports
-} from "./chunk-B4ECJJ5C.mjs";
-import {
-  NotificationServicesController,
-  defaultState
-} from "./chunk-5OYPOYXZ.mjs";
-import {
-  FEATURE_ANNOUNCEMENT_API
-} from "./chunk-EQWVJX6K.mjs";
-import {
-  NOTIFICATION_API_LIST_ENDPOINT,
-  NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT,
-  TRIGGER_API_BATCH_ENDPOINT
-} from "./chunk-UIRZIKC3.mjs";
-import {
-  initializeUserStorage
+  makeApiCall,
+  toggleUserStorageTriggerStatus,
+  traverseUserStorageTriggers
 } from "./chunk-SMKJEA45.mjs";
-import {
-  constants_exports
-} from "./chunk-VE4DTN4R.mjs";
-import {
-  USER_STORAGE_VERSION_KEY
-} from "./chunk-6ZDVTRRT.mjs";
 import {
   __commonJS,
   __export,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
   __require,
   __toESM
 } from "./chunk-26CCETCM.mjs";
@@ -169,12 +150,12 @@ var require_common = __commonJS({
       createDebug.skips = [];
       createDebug.formatters = {};
       function selectColor(namespace) {
-        let hash = 0;
+        let hash2 = 0;
         for (let i = 0; i < namespace.length; i++) {
-          hash = (hash << 5) - hash + namespace.charCodeAt(i);
-          hash |= 0;
+          hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
+          hash2 |= 0;
         }
-        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+        return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
       }
       createDebug.selectColor = selectColor;
       function createDebug(namespace) {
@@ -578,15 +559,15 @@ var require_common2 = __commonJS({
     function stringifyRequest(options, body) {
       const { method = "GET", path = "", port } = options;
       const origin = normalizeOrigin(options.proto, options.hostname, port);
-      const log = {
+      const log3 = {
         method,
         url: `${origin}${path}`,
         headers: options.headers
       };
       if (body) {
-        log.body = body;
+        log3.body = body;
       }
-      return JSON.stringify(log, null, 2);
+      return JSON.stringify(log3, null, 2);
     }
     function isContentEncoded(headers) {
       const contentEncoding2 = headers["content-encoding"];
@@ -1691,7 +1672,7 @@ var require_interceptor = __commonJS({
     "use strict";
     var stringify = require_stringify();
     var querystring = __require("querystring");
-    var { URL, URLSearchParams } = __require("url");
+    var { URL: URL2, URLSearchParams } = __require("url");
     var common = require_common2();
     var { remove } = require_intercept();
     var matchBody = require_match_body();
@@ -1745,7 +1726,7 @@ var require_interceptor = __commonJS({
         this.delayConnectionInMs = 0;
         this.optional = false;
         if (uriIsStr && uri.includes("?")) {
-          const parsedURL = new URL(this.path, "http://localhost");
+          const parsedURL = new URL2(this.path, "http://localhost");
           this.path = parsedURL.pathname;
           this.query(parsedURL.searchParams);
           this._key = `${this.method} ${scope.basePath}${this.path}`;
@@ -2742,18 +2723,18 @@ var require_scope = __commonJS({
     var debug = require_browser()("nock.scope");
     var { EventEmitter } = __require("events");
     var Interceptor = require_interceptor();
-    var { URL, Url: LegacyUrl } = url;
+    var { URL: URL2, Url: LegacyUrl } = url;
     var fs;
     try {
       fs = __require("fs");
     } catch (err) {
     }
     function normalizeUrl(u) {
-      if (!(u instanceof URL)) {
+      if (!(u instanceof URL2)) {
         if (u instanceof LegacyUrl) {
-          return normalizeUrl(new URL(url.format(u)));
+          return normalizeUrl(new URL2(url.format(u)));
         }
-        return normalizeUrl(new URL(u));
+        return normalizeUrl(new URL2(u));
       }
       if (!/https?:/.test(u.protocol)) {
         throw new TypeError(
@@ -3299,13 +3280,13 @@ var require_back = __commonJS({
       lockdown
       // use recorded nocks, disables all http calls even when not nocked, doesnt record
     };
-    Back.setMode = function(mode) {
-      if (!(mode in Modes)) {
-        throw new Error(`Unknown mode: ${mode}`);
+    Back.setMode = function(mode2) {
+      if (!(mode2 in Modes)) {
+        throw new Error(`Unknown mode: ${mode2}`);
       }
-      Back.currentMode = mode;
+      Back.currentMode = mode2;
       debug("New nock back mode:", Back.currentMode);
-      _mode = Modes[mode];
+      _mode = Modes[mode2];
       _mode.setup();
     };
     Back.fixtures = null;
@@ -3365,936 +3346,2329 @@ var require_nock = __commonJS({
   }
 });
 
-// src/NotificationServicesController/index.ts
-var NotificationServicesController_exports = {};
-__export(NotificationServicesController_exports, {
-  Constants: () => constants_exports,
-  Mocks: () => fixtures_exports,
-  NotificationServicesController: () => NotificationServicesController,
-  Processors: () => processors_exports,
-  Types: () => types_exports,
-  defaultState: () => defaultState
-});
+// ../profile-sync-controller/src/sdk/env.ts
+var ENV_URLS = {
+  dev: {
+    authApiUrl: "https://authentication.dev-api.cx.metamask.io",
+    oidcApiUrl: "https://oidc.dev-api.cx.metamask.io",
+    userStorageApiUrl: "https://user-storage.dev-api.cx.metamask.io"
+  },
+  uat: {
+    authApiUrl: "https://authentication.uat-api.cx.metamask.io",
+    oidcApiUrl: "https://oidc.uat-api.cx.metamask.io",
+    userStorageApiUrl: "https://user-storage.uat-api.cx.metamask.io"
+  },
+  prd: {
+    authApiUrl: "https://authentication.api.cx.metamask.io",
+    oidcApiUrl: "https://oidc.api.cx.metamask.io",
+    userStorageApiUrl: "https://user-storage.api.cx.metamask.io"
+  }
+};
+function getEnvUrls(env) {
+  if (!ENV_URLS[env]) {
+    throw new Error("invalid environment configuration");
+  }
+  return ENV_URLS[env];
+}
 
-// src/NotificationServicesController/__fixtures__/index.ts
-var fixtures_exports = {};
-__export(fixtures_exports, {
-  CONTENTFUL_RESPONSE: () => CONTENTFUL_RESPONSE,
-  MOCK_RAW_ON_CHAIN_NOTIFICATIONS: () => MOCK_RAW_ON_CHAIN_NOTIFICATIONS,
-  MOCK_USER_STORAGE_ACCOUNT: () => MOCK_USER_STORAGE_ACCOUNT,
-  MOCK_USER_STORAGE_CHAIN: () => MOCK_USER_STORAGE_CHAIN,
-  createMockFeatureAnnouncementAPIResult: () => createMockFeatureAnnouncementAPIResult,
-  createMockFeatureAnnouncementRaw: () => createMockFeatureAnnouncementRaw,
-  createMockFullUserStorage: () => createMockFullUserStorage,
-  createMockNotificationERC1155Received: () => createMockNotificationERC1155Received,
-  createMockNotificationERC1155Sent: () => createMockNotificationERC1155Sent,
-  createMockNotificationERC20Received: () => createMockNotificationERC20Received,
-  createMockNotificationERC20Sent: () => createMockNotificationERC20Sent,
-  createMockNotificationERC721Received: () => createMockNotificationERC721Received,
-  createMockNotificationERC721Sent: () => createMockNotificationERC721Sent,
-  createMockNotificationEthReceived: () => createMockNotificationEthReceived,
-  createMockNotificationEthSent: () => createMockNotificationEthSent,
-  createMockNotificationLidoReadyToBeWithdrawn: () => createMockNotificationLidoReadyToBeWithdrawn,
-  createMockNotificationLidoStakeCompleted: () => createMockNotificationLidoStakeCompleted,
-  createMockNotificationLidoWithdrawalCompleted: () => createMockNotificationLidoWithdrawalCompleted,
-  createMockNotificationLidoWithdrawalRequested: () => createMockNotificationLidoWithdrawalRequested,
-  createMockNotificationMetaMaskSwapsCompleted: () => createMockNotificationMetaMaskSwapsCompleted,
-  createMockNotificationRocketPoolStakeCompleted: () => createMockNotificationRocketPoolStakeCompleted,
-  createMockNotificationRocketPoolUnStakeCompleted: () => createMockNotificationRocketPoolUnStakeCompleted,
-  createMockNotificationTrigger: () => createMockNotificationTrigger,
-  createMockRawOnChainNotifications: () => createMockRawOnChainNotifications,
-  createMockUserStorage: () => createMockUserStorage,
-  createMockUserStorageWithTriggers: () => createMockUserStorageWithTriggers,
-  getMockBatchCreateTriggersResponse: () => getMockBatchCreateTriggersResponse,
-  getMockBatchDeleteTriggersResponse: () => getMockBatchDeleteTriggersResponse,
-  getMockFeatureAnnouncementResponse: () => getMockFeatureAnnouncementResponse,
-  getMockListNotificationsResponse: () => getMockListNotificationsResponse,
-  getMockMarkNotificationsAsReadResponse: () => getMockMarkNotificationsAsReadResponse,
-  mockBatchCreateTriggers: () => mockBatchCreateTriggers,
-  mockBatchDeleteTriggers: () => mockBatchDeleteTriggers,
-  mockFetchFeatureAnnouncementNotifications: () => mockFetchFeatureAnnouncementNotifications,
-  mockListNotifications: () => mockListNotifications,
-  mockMarkNotificationsAsRead: () => mockMarkNotificationsAsRead
-});
+// ../../node_modules/@noble/ciphers/esm/_assert.js
+function isBytes(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+function bytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+}
+function exists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+  bytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
 
-// src/NotificationServicesController/__fixtures__/mock-feature-announcements.ts
-function createMockFeatureAnnouncementAPIResult() {
+// ../../node_modules/@noble/ciphers/esm/utils.js
+var u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!isLE)
+  throw new Error("Non little-endian hardware is not supported");
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`string expected, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  else if (isBytes(data))
+    data = data.slice();
+  else
+    throw new Error(`Uint8Array expected, got ${typeof data}`);
+  return data;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, c) => {
+  Object.assign(c, params);
+  return c;
+};
+function setBigUint64(view, byteOffset, value, isLE3) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE3);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE3 ? 4 : 0;
+  const l = isLE3 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE3);
+  view.setUint32(byteOffset + l, wl, isLE3);
+}
+
+// ../../node_modules/@noble/ciphers/esm/_polyval.js
+var BLOCK_SIZE = 16;
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var ZEROS32 = u32(ZEROS16);
+var POLY = 225;
+var mul2 = (s0, s1, s2, s3) => {
+  const hiBit = s3 & 1;
   return {
-    sys: {
-      type: "Array"
-    },
-    total: 17,
-    skip: 0,
-    limit: 1,
-    items: [
-      {
-        metadata: {
-          tags: []
-        },
-        sys: {
-          space: {
-            sys: {
-              type: "Link",
-              linkType: "Space",
-              id: "jdkgyfmyd9sw"
-            }
-          },
-          id: "1ABRmHaNCgmxROKXXLXsMu",
-          type: "Entry",
-          createdAt: "2024-04-09T13:24:01.872Z",
-          updatedAt: "2024-04-09T13:24:01.872Z",
-          environment: {
-            sys: {
-              id: "master",
-              type: "Link",
-              linkType: "Environment"
-            }
-          },
-          revision: 1,
-          contentType: {
-            sys: {
-              type: "Link",
-              linkType: "ContentType",
-              id: "productAnnouncement"
-            }
-          },
-          locale: "en-US"
-        },
-        fields: {
-          title: "Don\u2019t miss out on airdrops and new NFT mints!",
-          id: "dont-miss-out-on-airdrops-and-new-nft-mints",
-          category: "ANNOUNCEMENT",
-          shortDescription: "Check your airdrop eligibility and see trending NFT drops. Head over to the Explore tab to get started. ",
-          image: {
-            sys: {
-              type: "Link",
-              linkType: "Asset",
-              id: "5jqq8sFeLc6XEoeWlpI3aB"
-            }
-          },
-          longDescription: {
-            data: {},
-            content: [
-              {
-                data: {},
-                content: [
-                  {
-                    data: {},
-                    marks: [],
-                    value: "You can now verify if any of your connected addresses are eligible for airdrops and other ERC-20 claims in a secure and convenient way. We\u2019ve also added trending NFT mints based on creators you\u2019ve minted from before or other tokens you hold. Head over to the Explore tab to get started. \n",
-                    nodeType: "text"
-                  }
-                ],
-                nodeType: "paragraph"
-              }
-            ],
-            nodeType: "document"
-          },
-          link: {
-            sys: {
-              type: "Link",
-              linkType: "Entry",
-              id: "62xKYM2ydo4F1mS5q97K5q"
-            }
-          }
+    s3: s2 << 31 | s3 >>> 1,
+    s2: s1 << 31 | s2 >>> 1,
+    s1: s0 << 31 | s1 >>> 1,
+    s0: s0 >>> 1 ^ POLY << 24 & -(hiBit & 1)
+    // reduce % poly
+  };
+};
+var swapLE = (n) => (n >>> 0 & 255) << 24 | (n >>> 8 & 255) << 16 | (n >>> 16 & 255) << 8 | n >>> 24 & 255 | 0;
+function _toGHASHKey(k) {
+  k.reverse();
+  const hiBit = k[15] & 1;
+  let carry = 0;
+  for (let i = 0; i < k.length; i++) {
+    const t = k[i];
+    k[i] = t >>> 1 | carry;
+    carry = (t & 1) << 7;
+  }
+  k[0] ^= -hiBit & 225;
+  return k;
+}
+var estimateWindow = (bytes3) => {
+  if (bytes3 > 64 * 1024)
+    return 8;
+  if (bytes3 > 1024)
+    return 4;
+  return 2;
+};
+var GHASH = class {
+  // We select bits per window adaptively based on expectedLength
+  constructor(key, expectedLength) {
+    this.blockLen = BLOCK_SIZE;
+    this.outputLen = BLOCK_SIZE;
+    this.s0 = 0;
+    this.s1 = 0;
+    this.s2 = 0;
+    this.s3 = 0;
+    this.finished = false;
+    key = toBytes(key);
+    bytes(key, 16);
+    const kView = createView(key);
+    let k0 = kView.getUint32(0, false);
+    let k1 = kView.getUint32(4, false);
+    let k2 = kView.getUint32(8, false);
+    let k3 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i = 0; i < 128; i++) {
+      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
+      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));
+    }
+    const W = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W))
+      throw new Error(`ghash: wrong window size=${W}, should be 2, 4 or 8`);
+    this.W = W;
+    const bits = 128;
+    const windows = bits / W;
+    const windowSize = this.windowSize = 2 ** W;
+    const items = [];
+    for (let w = 0; w < windows; w++) {
+      for (let byte = 0; byte < windowSize; byte++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (let j = 0; j < W; j++) {
+          const bit = byte >>> W - j - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];
+          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
         }
+        items.push({ s0, s1, s2, s3 });
       }
-    ],
-    includes: {
-      Entry: [
-        {
-          metadata: {
-            tags: []
-          },
-          sys: {
-            space: {
-              sys: {
-                type: "Link",
-                linkType: "Space",
-                id: "jdkgyfmyd9sw"
-              }
-            },
-            id: "62xKYM2ydo4F1mS5q97K5q",
-            type: "Entry",
-            createdAt: "2024-04-09T13:23:03.636Z",
-            updatedAt: "2024-04-09T13:23:03.636Z",
-            environment: {
-              sys: {
-                id: "master",
-                type: "Link",
-                linkType: "Environment"
-              }
-            },
-            revision: 1,
-            contentType: {
-              sys: {
-                type: "Link",
-                linkType: "ContentType",
-                id: "link"
-              }
-            },
-            locale: "en-US"
-          },
-          fields: {
-            extensionLinkText: "Try now",
-            extensionLinkRoute: "home.html"
-          }
-        }
-      ],
-      Asset: [
-        {
-          metadata: {
-            tags: []
-          },
-          sys: {
-            space: {
-              sys: {
-                type: "Link",
-                linkType: "Space",
-                id: "jdkgyfmyd9sw"
-              }
-            },
-            id: "5jqq8sFeLc6XEoeWlpI3aB",
-            type: "Asset",
-            createdAt: "2024-04-09T13:23:13.327Z",
-            updatedAt: "2024-04-09T13:23:13.327Z",
-            environment: {
-              sys: {
-                id: "master",
-                type: "Link",
-                linkType: "Environment"
-              }
-            },
-            revision: 1,
-            locale: "en-US"
-          },
-          fields: {
-            title: "PDAPP notification image Airdrops & NFT mints",
-            description: "",
-            file: {
-              url: "//images.ctfassets.net/jdkgyfmyd9sw/5jqq8sFeLc6XEoeWlpI3aB/73ee0f1afa9916c3a7538b0bbee09c26/PDAPP_notification_image_Airdrops___NFT_mints.png",
-              details: {
-                size: 797731,
-                image: {
-                  width: 2880,
-                  height: 1921
-                }
-              },
-              fileName: "PDAPP notification image_Airdrops & NFT mints.png",
-              contentType: "image/png"
-            }
-          }
-        }
-      ]
     }
-  };
-}
-function createMockFeatureAnnouncementRaw() {
-  return {
-    type: "features_announcement" /* FEATURES_ANNOUNCEMENT */,
-    createdAt: "2999-04-09T13:24:01.872Z",
-    data: {
-      id: "dont-miss-out-on-airdrops-and-new-nft-mints",
-      category: "ANNOUNCEMENT",
-      title: "Don\u2019t miss out on airdrops and new NFT mints!",
-      longDescription: `<p>You can now verify if any of your connected addresses are eligible for airdrops and other ERC-20 claims in a secure and convenient way. We\u2019ve also added trending NFT mints based on creators you\u2019ve minted from before or other tokens you hold. Head over to the Explore tab to get started.</p>`,
-      shortDescription: "Check your airdrop eligibility and see trending NFT drops. Head over to the Explore tab to get started.",
-      image: {
-        title: "PDAPP notification image Airdrops & NFT mints",
-        description: "",
-        url: "//images.ctfassets.net/jdkgyfmyd9sw/5jqq8sFeLc6XEoeWlpI3aB/73ee0f1afa9916c3a7538b0bbee09c26/PDAPP_notification_image_Airdrops___NFT_mints.png"
-      },
-      extensionLink: {
-        extensionLinkText: "Try now",
-        extensionLinkRoute: "home.html"
+    this.t = items;
+  }
+  _updateBlock(s0, s1, s2, s3) {
+    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
+    const { W, t, windowSize } = this;
+    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
+    const mask = (1 << W) - 1;
+    let w = 0;
+    for (const num of [s0, s1, s2, s3]) {
+      for (let bytePos = 0; bytePos < 4; bytePos++) {
+        const byte = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W - 1; bitPos >= 0; bitPos--) {
+          const bit = byte >>> W * bitPos & mask;
+          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
+          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
+          w += 1;
+        }
       }
     }
-  };
+    this.s0 = o0;
+    this.s1 = o1;
+    this.s2 = o2;
+    this.s3 = o3;
+  }
+  update(data) {
+    data = toBytes(data);
+    exists(this);
+    const b32 = u32(data);
+    const blocks = Math.floor(data.length / BLOCK_SIZE);
+    const left = data.length % BLOCK_SIZE;
+    for (let i = 0; i < blocks; i++) {
+      this._updateBlock(b32[i * 4 + 0], b32[i * 4 + 1], b32[i * 4 + 2], b32[i * 4 + 3]);
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
+      this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);
+      ZEROS32.fill(0);
+    }
+    return this;
+  }
+  destroy() {
+    const { t } = this;
+    for (const elm of t) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    }
+  }
+  digestInto(out) {
+    exists(this);
+    output(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out;
+  }
+  digest() {
+    const res = new Uint8Array(BLOCK_SIZE);
+    this.digestInto(res);
+    this.destroy();
+    return res;
+  }
+};
+var Polyval = class extends GHASH {
+  constructor(key, expectedLength) {
+    key = toBytes(key);
+    const ghKey = _toGHASHKey(key.slice());
+    super(ghKey, expectedLength);
+    ghKey.fill(0);
+  }
+  update(data) {
+    data = toBytes(data);
+    exists(this);
+    const b32 = u32(data);
+    const left = data.length % BLOCK_SIZE;
+    const blocks = Math.floor(data.length / BLOCK_SIZE);
+    for (let i = 0; i < blocks; i++) {
+      this._updateBlock(swapLE(b32[i * 4 + 3]), swapLE(b32[i * 4 + 2]), swapLE(b32[i * 4 + 1]), swapLE(b32[i * 4 + 0]));
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
+      this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0]));
+      ZEROS32.fill(0);
+    }
+    return this;
+  }
+  digestInto(out) {
+    exists(this);
+    output(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out.reverse();
+  }
+};
+function wrapConstructorWithKey(hashCons) {
+  const hashC = (msg, key) => hashCons(key, msg.length).update(toBytes(msg)).digest();
+  const tmp = hashCons(new Uint8Array(16), 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (key, expectedLength) => hashCons(key, expectedLength);
+  return hashC;
 }
+var ghash = wrapConstructorWithKey((key, expectedLength) => new GHASH(key, expectedLength));
+var polyval = wrapConstructorWithKey((key, expectedLength) => new Polyval(key, expectedLength));
 
-// src/NotificationServicesController/__fixtures__/mock-notification-trigger.ts
-import { v4 as uuidv4 } from "uuid";
-function createMockNotificationTrigger(override) {
+// ../../node_modules/@noble/ciphers/esm/aes.js
+var BLOCK_SIZE2 = 16;
+var BLOCK_SIZE32 = 4;
+var EMPTY_BLOCK = new Uint8Array(BLOCK_SIZE2);
+var POLY2 = 283;
+function mul22(n) {
+  return n << 1 ^ POLY2 & -(n >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul22(a);
+  }
+  return res;
+}
+var sbox = /* @__PURE__ */ (() => {
+  let t = new Uint8Array(256);
+  for (let i = 0, x = 1; i < 256; i++, x ^= mul22(x))
+    t[i] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i = 0; i < 255; i++) {
+    let x = t[255 - i];
+    x |= x << 8;
+    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  return box;
+})();
+var invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+var rotr32_8 = (n) => n << 24 | n >>> 8;
+var rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("Wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i = 0; i < 256; i++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i * 256 + j;
+      T01[idx] = T0[i] ^ T1[j];
+      T23[idx] = T2[i] ^ T3[j];
+      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+var tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
+var xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i = 0, x = 1; i < 16; i++, x = mul22(x))
+    p[i] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  bytes(key);
+  const len = key.length;
+  if (![16, 24, 32].includes(len))
+    throw new Error(`aes: wrong key size: should be 16, 24 or 32, got: ${len}`);
+  const { sbox2 } = tableEncoding;
+  const k32 = u32(key);
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i = Nk; i < xk.length; i++) {
+    let t = xk[i - 1];
+    if (i % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
+    else if (Nk > 6 && i % Nk === 4)
+      t = subByte(t);
+    xk[i] = xk[i - Nk] ^ t;
+  }
+  return xk;
+}
+function expandKeyDecLE(key) {
+  const encKey = expandKeyLE(key);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0, T1, T2, T3 } = tableDecoding;
+  for (let i = 0; i < Nk; i += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i + j] = encKey[Nk - i - 4 + j];
+  }
+  encKey.fill(0);
+  for (let i = 4; i < Nk - 4; i++) {
+    const x = xk[i];
+    const w = applySbox(sbox2, x, x, x, x);
+    xk[i] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+  }
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0; i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function decrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableDecoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0; i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function getDst(len, dst) {
+  if (!dst)
+    return new Uint8Array(len);
+  bytes(dst);
+  if (dst.length < len)
+    throw new Error(`aes: wrong destination length, expected at least ${len}, got: ${dst.length}`);
+  return dst;
+}
+function ctrCounter(xk, nonce, src, dst) {
+  bytes(nonce, BLOCK_SIZE2);
+  bytes(src);
+  const srcLen = src.length;
+  dst = getDst(srcLen, dst);
+  const ctr4 = nonce;
+  const c32 = u32(ctr4);
+  let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  for (let i = 0; i + 4 <= src32.length; i += 4) {
+    dst32[i + 0] = src32[i + 0] ^ s0;
+    dst32[i + 1] = src32[i + 1] ^ s1;
+    dst32[i + 2] = src32[i + 2] ^ s2;
+    dst32[i + 3] = src32[i + 3] ^ s3;
+    let carry = 1;
+    for (let i2 = ctr4.length - 1; i2 >= 0; i2--) {
+      carry = carry + (ctr4[i2] & 255) | 0;
+      ctr4[i2] = carry & 255;
+      carry >>>= 8;
+    }
+    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
+  }
+  const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    const buf = u8(b32);
+    for (let i = start, pos = 0; i < srcLen; i++, pos++)
+      dst[i] = src[i] ^ buf[pos];
+  }
+  return dst;
+}
+function ctr32(xk, isLE3, nonce, src, dst) {
+  bytes(nonce, BLOCK_SIZE2);
+  bytes(src);
+  dst = getDst(src.length, dst);
+  const ctr4 = nonce;
+  const c32 = u32(ctr4);
+  const view = createView(ctr4);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  const ctrPos = isLE3 ? 0 : 12;
+  const srcLen = src.length;
+  let ctrNum = view.getUint32(ctrPos, isLE3);
+  let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
+  for (let i = 0; i + 4 <= src32.length; i += 4) {
+    dst32[i + 0] = src32[i + 0] ^ s0;
+    dst32[i + 1] = src32[i + 1] ^ s1;
+    dst32[i + 2] = src32[i + 2] ^ s2;
+    dst32[i + 3] = src32[i + 3] ^ s3;
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE3);
+    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
+  }
+  const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    const buf = u8(b32);
+    for (let i = start, pos = 0; i < srcLen; i++, pos++)
+      dst[i] = src[i] ^ buf[pos];
+  }
+  return dst;
+}
+var ctr = wrapCipher({ blockSize: 16, nonceLength: 16 }, function ctr2(key, nonce) {
+  bytes(key);
+  bytes(nonce, BLOCK_SIZE2);
+  function processCtr(buf, dst) {
+    const xk = expandKeyLE(key);
+    const n = nonce.slice();
+    const out = ctrCounter(xk, n, buf, dst);
+    xk.fill(0);
+    n.fill(0);
+    return out;
+  }
   return {
-    id: uuidv4(),
-    address: "0xFAKE_ADDRESS",
-    chainId: "1",
-    kind: "eth_sent",
-    enabled: true,
-    ...override
+    encrypt: (plaintext, dst) => processCtr(plaintext, dst),
+    decrypt: (ciphertext, dst) => processCtr(ciphertext, dst)
   };
+});
+function validateBlockDecrypt(data) {
+  bytes(data);
+  if (data.length % BLOCK_SIZE2 !== 0) {
+    throw new Error(`aes/(cbc-ecb).decrypt ciphertext should consist of blocks with size ${BLOCK_SIZE2}`);
+  }
 }
-
-// src/NotificationServicesController/__fixtures__/mock-notification-user-storage.ts
-var MOCK_USER_STORAGE_ACCOUNT = "0x0000000000000000000000000000000000000000";
-var MOCK_USER_STORAGE_CHAIN = "1";
-function createMockUserStorage(override) {
+function validateBlockEncrypt(plaintext, pcks5, dst) {
+  let outLen = plaintext.length;
+  const remaining = outLen % BLOCK_SIZE2;
+  if (!pcks5 && remaining !== 0)
+    throw new Error("aec/(cbc-ecb): unpadded plaintext with disabled padding");
+  const b = u32(plaintext);
+  if (pcks5) {
+    let left = BLOCK_SIZE2 - remaining;
+    if (!left)
+      left = BLOCK_SIZE2;
+    outLen = outLen + left;
+  }
+  const out = getDst(outLen, dst);
+  const o = u32(out);
+  return { b, o, out };
+}
+function validatePCKS(data, pcks5) {
+  if (!pcks5)
+    return data;
+  const len = data.length;
+  if (!len)
+    throw new Error(`aes/pcks5: empty ciphertext not allowed`);
+  const lastByte = data[len - 1];
+  if (lastByte <= 0 || lastByte > 16)
+    throw new Error(`aes/pcks5: wrong padding byte: ${lastByte}`);
+  const out = data.subarray(0, -lastByte);
+  for (let i = 0; i < lastByte; i++)
+    if (data[len - i - 1] !== lastByte)
+      throw new Error(`aes/pcks5: wrong padding`);
+  return out;
+}
+function padPCKS(left) {
+  const tmp = new Uint8Array(16);
+  const tmp32 = u32(tmp);
+  tmp.set(left);
+  const paddingByte = BLOCK_SIZE2 - left.length;
+  for (let i = BLOCK_SIZE2 - paddingByte; i < BLOCK_SIZE2; i++)
+    tmp[i] = paddingByte;
+  return tmp32;
+}
+var ecb = wrapCipher({ blockSize: 16 }, function ecb2(key, opts = {}) {
+  bytes(key);
+  const pcks5 = !opts.disablePadding;
   return {
-    [USER_STORAGE_VERSION_KEY]: "1",
-    [MOCK_USER_STORAGE_ACCOUNT]: {
-      [MOCK_USER_STORAGE_CHAIN]: {
-        "111-111-111-111": {
-          k: "erc20_received" /* ERC20_RECEIVED */,
-          e: true
-        },
-        "222-222-222-222": {
-          k: "erc20_sent" /* ERC20_SENT */,
-          e: true
-        }
-      }
+    encrypt: (plaintext, dst) => {
+      bytes(plaintext);
+      const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);
+      const xk = expandKeyLE(key);
+      let i = 0;
+      for (; i + 4 <= b.length; ) {
+        const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      if (pcks5) {
+        const tmp32 = padPCKS(plaintext.subarray(i * 4));
+        const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      xk.fill(0);
+      return _out;
     },
-    ...override
+    decrypt: (ciphertext, dst) => {
+      validateBlockDecrypt(ciphertext);
+      const xk = expandKeyDecLE(key);
+      const out = getDst(ciphertext.length, dst);
+      const b = u32(ciphertext);
+      const o = u32(out);
+      for (let i = 0; i + 4 <= b.length; ) {
+        const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      xk.fill(0);
+      return validatePCKS(out, pcks5);
+    }
   };
-}
-function createMockUserStorageWithTriggers(triggers) {
-  const userStorage = {
-    [USER_STORAGE_VERSION_KEY]: "1",
-    [MOCK_USER_STORAGE_ACCOUNT]: {
-      [MOCK_USER_STORAGE_CHAIN]: {}
+});
+var cbc = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cbc2(key, iv, opts = {}) {
+  bytes(key);
+  bytes(iv, 16);
+  const pcks5 = !opts.disablePadding;
+  return {
+    encrypt: (plaintext, dst) => {
+      const xk = expandKeyLE(key);
+      const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);
+      const n32 = u32(iv);
+      let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
+      let i = 0;
+      for (; i + 4 <= b.length; ) {
+        s0 ^= b[i + 0], s1 ^= b[i + 1], s2 ^= b[i + 2], s3 ^= b[i + 3];
+        ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      if (pcks5) {
+        const tmp32 = padPCKS(plaintext.subarray(i * 4));
+        s0 ^= tmp32[0], s1 ^= tmp32[1], s2 ^= tmp32[2], s3 ^= tmp32[3];
+        ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      xk.fill(0);
+      return _out;
+    },
+    decrypt: (ciphertext, dst) => {
+      validateBlockDecrypt(ciphertext);
+      const xk = expandKeyDecLE(key);
+      const n32 = u32(iv);
+      const out = getDst(ciphertext.length, dst);
+      const b = u32(ciphertext);
+      const o = u32(out);
+      let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
+      for (let i = 0; i + 4 <= b.length; ) {
+        const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;
+        s0 = b[i + 0], s1 = b[i + 1], s2 = b[i + 2], s3 = b[i + 3];
+        const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);
+        o[i++] = o0 ^ ps0, o[i++] = o1 ^ ps1, o[i++] = o2 ^ ps2, o[i++] = o3 ^ ps3;
+      }
+      xk.fill(0);
+      return validatePCKS(out, pcks5);
     }
   };
-  triggers.forEach((t) => {
-    let tId;
-    let e;
-    let k;
-    if (typeof t === "string") {
-      tId = t;
-      e = true;
-      k = "erc20_received" /* ERC20_RECEIVED */;
-    } else {
-      tId = t.id;
-      e = t.e;
-      k = t.k ?? "erc20_received" /* ERC20_RECEIVED */;
+});
+var cfb = wrapCipher({ blockSize: 16, nonceLength: 16 }, function cfb2(key, iv) {
+  bytes(key);
+  bytes(iv, 16);
+  function processCfb(src, isEncrypt, dst) {
+    const xk = expandKeyLE(key);
+    const srcLen = src.length;
+    dst = getDst(srcLen, dst);
+    const src32 = u32(src);
+    const dst32 = u32(dst);
+    const next32 = isEncrypt ? dst32 : src32;
+    const n32 = u32(iv);
+    let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
+    for (let i = 0; i + 4 <= src32.length; ) {
+      const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);
+      dst32[i + 0] = src32[i + 0] ^ e0;
+      dst32[i + 1] = src32[i + 1] ^ e1;
+      dst32[i + 2] = src32[i + 2] ^ e2;
+      dst32[i + 3] = src32[i + 3] ^ e3;
+      s0 = next32[i++], s1 = next32[i++], s2 = next32[i++], s3 = next32[i++];
     }
-    userStorage[MOCK_USER_STORAGE_ACCOUNT][MOCK_USER_STORAGE_CHAIN][tId] = {
-      k,
-      e
-    };
-  });
-  return userStorage;
-}
-function createMockFullUserStorage(props = {}) {
-  return initializeUserStorage(
-    [{ address: props.address ?? MOCK_USER_STORAGE_ACCOUNT }],
-    props.triggersEnabled ?? true
-  );
-}
-
-// src/NotificationServicesController/__fixtures__/mock-raw-notifications.ts
-function createMockNotificationEthSent() {
-  const mockNotification = {
-    type: "eth_sent" /* ETH_SENT */,
-    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    chain_id: 1,
-    block_number: 17485840,
-    block_timestamp: "2022-03-01T00:00:00Z",
-    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    unread: true,
-    created_at: "2022-03-01T00:00:00Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "eth_sent",
-      network_fee: {
-        gas_price: "207806259583",
-        native_token_price_in_usd: "0.83"
-      },
-      from: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-      to: "0x881D40237659C251811CEC9c364ef91dC08D300D",
-      amount: {
-        usd: "670.64",
-        eth: "0.005"
-      }
+    const start = BLOCK_SIZE2 * Math.floor(src32.length / BLOCK_SIZE32);
+    if (start < srcLen) {
+      ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
+      const buf = u8(new Uint32Array([s0, s1, s2, s3]));
+      for (let i = start, pos = 0; i < srcLen; i++, pos++)
+        dst[i] = src[i] ^ buf[pos];
+      buf.fill(0);
     }
+    xk.fill(0);
+    return dst;
+  }
+  return {
+    encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),
+    decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst)
   };
-  return mockNotification;
+});
+function computeTag(fn, isLE3, key, data, AAD) {
+  const h = fn.create(key, data.length + (AAD?.length || 0));
+  if (AAD)
+    h.update(AAD);
+  h.update(data);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  if (AAD)
+    setBigUint64(view, 0, BigInt(AAD.length * 8), isLE3);
+  setBigUint64(view, 8, BigInt(data.length * 8), isLE3);
+  h.update(num);
+  return h.digest();
 }
-function createMockNotificationEthReceived() {
-  const mockNotification = {
-    type: "eth_received" /* ETH_RECEIVED */,
-    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    chain_id: 1,
-    block_number: 17485840,
-    block_timestamp: "2022-03-01T00:00:00Z",
-    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    unread: true,
-    created_at: "2022-03-01T00:00:00Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "eth_received",
-      network_fee: {
-        gas_price: "207806259583",
-        native_token_price_in_usd: "0.83"
-      },
-      from: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-      to: "0x881D40237659C251811CEC9c364ef91dC08D300D",
-      amount: {
-        usd: "670.64",
-        eth: "808.000000000000000000"
+var gcm = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function gcm2(key, nonce, AAD) {
+  bytes(nonce);
+  if (nonce.length === 0)
+    throw new Error("aes/gcm: empty nonce");
+  const tagLength = 16;
+  function _computeTag(authKey, tagMask, data) {
+    const tag = computeTag(ghash, false, authKey, data, AAD);
+    for (let i = 0; i < tagMask.length; i++)
+      tag[i] ^= tagMask[i];
+    return tag;
+  }
+  function deriveKeys() {
+    const xk = expandKeyLE(key);
+    const authKey = EMPTY_BLOCK.slice();
+    const counter = EMPTY_BLOCK.slice();
+    ctr32(xk, false, counter, counter, authKey);
+    if (nonce.length === 12) {
+      counter.set(nonce);
+    } else {
+      const nonceLen = EMPTY_BLOCK.slice();
+      const view = createView(nonceLen);
+      setBigUint64(view, 8, BigInt(nonce.length * 8), false);
+      ghash.create(authKey).update(nonce).update(nonceLen).digestInto(counter);
+    }
+    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
+    return { xk, authKey, counter, tagMask };
+  }
+  return {
+    encrypt: (plaintext) => {
+      bytes(plaintext);
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const out = new Uint8Array(plaintext.length + tagLength);
+      ctr32(xk, false, counter, plaintext, out);
+      const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
+      out.set(tag, plaintext.length);
+      xk.fill(0);
+      return out;
+    },
+    decrypt: (ciphertext) => {
+      bytes(ciphertext);
+      if (ciphertext.length < tagLength)
+        throw new Error(`aes/gcm: ciphertext less than tagLen (${tagLength})`);
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = _computeTag(authKey, tagMask, data);
+      if (!equalBytes(tag, passedTag))
+        throw new Error("aes/gcm: invalid ghash tag");
+      const out = ctr32(xk, false, counter, data);
+      authKey.fill(0);
+      tagMask.fill(0);
+      xk.fill(0);
+      return out;
+    }
+  };
+});
+var limit = (name, min, max) => (value) => {
+  if (!Number.isSafeInteger(value) || min > value || value > max)
+    throw new Error(`${name}: invalid value=${value}, must be [${min}..${max}]`);
+};
+var siv = wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16 }, function siv2(key, nonce, AAD) {
+  const tagLength = 16;
+  const AAD_LIMIT = limit("AAD", 0, 2 ** 36);
+  const PLAIN_LIMIT = limit("plaintext", 0, 2 ** 36);
+  const NONCE_LIMIT = limit("nonce", 12, 12);
+  const CIPHER_LIMIT = limit("ciphertext", 16, 2 ** 36 + 16);
+  bytes(nonce);
+  NONCE_LIMIT(nonce.length);
+  if (AAD) {
+    bytes(AAD);
+    AAD_LIMIT(AAD.length);
+  }
+  function deriveKeys() {
+    const len = key.length;
+    if (len !== 16 && len !== 24 && len !== 32)
+      throw new Error(`key length must be 16, 24 or 32 bytes, got: ${len} bytes`);
+    const xk = expandKeyLE(key);
+    const encKey = new Uint8Array(len);
+    const authKey = new Uint8Array(16);
+    const n32 = u32(nonce);
+    let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];
+    let counter = 0;
+    for (const derivedKey of [authKey, encKey].map(u32)) {
+      const d32 = u32(derivedKey);
+      for (let i = 0; i < d32.length; i += 2) {
+        const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);
+        d32[i + 0] = o0;
+        d32[i + 1] = o1;
+        s0 = ++counter;
       }
     }
+    xk.fill(0);
+    return { authKey, encKey: expandKeyLE(encKey) };
+  }
+  function _computeTag(encKey, authKey, data) {
+    const tag = computeTag(polyval, true, authKey, data, AAD);
+    for (let i = 0; i < 12; i++)
+      tag[i] ^= nonce[i];
+    tag[15] &= 127;
+    const t32 = u32(tag);
+    let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];
+    ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));
+    t32[0] = s0, t32[1] = s1, t32[2] = s2, t32[3] = s3;
+    return tag;
+  }
+  function processSiv(encKey, tag, input) {
+    let block = tag.slice();
+    block[15] |= 128;
+    return ctr32(encKey, true, block, input);
+  }
+  return {
+    encrypt: (plaintext) => {
+      bytes(plaintext);
+      PLAIN_LIMIT(plaintext.length);
+      const { encKey, authKey } = deriveKeys();
+      const tag = _computeTag(encKey, authKey, plaintext);
+      const out = new Uint8Array(plaintext.length + tagLength);
+      out.set(tag, plaintext.length);
+      out.set(processSiv(encKey, tag, plaintext));
+      encKey.fill(0);
+      authKey.fill(0);
+      return out;
+    },
+    decrypt: (ciphertext) => {
+      bytes(ciphertext);
+      CIPHER_LIMIT(ciphertext.length);
+      const tag = ciphertext.subarray(-tagLength);
+      const { encKey, authKey } = deriveKeys();
+      const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));
+      const expectedTag = _computeTag(encKey, authKey, plaintext);
+      encKey.fill(0);
+      authKey.fill(0);
+      if (!equalBytes(tag, expectedTag))
+        throw new Error("invalid polyval tag");
+      return plaintext;
+    }
   };
-  return mockNotification;
+});
+
+// ../../node_modules/@noble/ciphers/esm/crypto.js
+var cr = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+function randomBytes(bytesLength = 32) {
+  if (cr && typeof cr.getRandomValues === "function")
+    return cr.getRandomValues(new Uint8Array(bytesLength));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+function getWebcryptoSubtle() {
+  if (cr && typeof cr.subtle === "object" && cr.subtle != null)
+    return cr.subtle;
+  throw new Error("crypto.subtle must be defined");
+}
+
+// ../../node_modules/@noble/ciphers/esm/webcrypto.js
+var utils = {
+  async encrypt(key, keyParams, cryptParams, plaintext) {
+    const cr2 = getWebcryptoSubtle();
+    const iKey = await cr2.importKey("raw", key, keyParams, true, ["encrypt"]);
+    const ciphertext = await cr2.encrypt(cryptParams, iKey, plaintext);
+    return new Uint8Array(ciphertext);
+  },
+  async decrypt(key, keyParams, cryptParams, ciphertext) {
+    const cr2 = getWebcryptoSubtle();
+    const iKey = await cr2.importKey("raw", key, keyParams, true, ["decrypt"]);
+    const plaintext = await cr2.decrypt(cryptParams, iKey, ciphertext);
+    return new Uint8Array(plaintext);
+  }
+};
+var mode = {
+  CBC: "AES-CBC",
+  CTR: "AES-CTR",
+  GCM: "AES-GCM"
+};
+function getCryptParams(algo, nonce, AAD) {
+  if (algo === mode.CBC)
+    return { name: mode.CBC, iv: nonce };
+  if (algo === mode.CTR)
+    return { name: mode.CTR, counter: nonce, length: 64 };
+  if (algo === mode.GCM)
+    return { name: mode.GCM, iv: nonce, additionalData: AAD };
+  throw new Error("unknown aes block mode");
 }
-function createMockNotificationERC20Sent() {
-  const mockNotification = {
-    type: "erc20_sent" /* ERC20_SENT */,
-    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    chain_id: 1,
-    block_number: 17485840,
-    block_timestamp: "2022-03-01T00:00:00Z",
-    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    unread: true,
-    created_at: "2022-03-01T00:00:00Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "erc20_sent",
-      network_fee: {
-        gas_price: "207806259583",
-        native_token_price_in_usd: "0.83"
+function generate(algo) {
+  return (key, nonce, AAD) => {
+    bytes(key);
+    bytes(nonce);
+    const keyParams = { name: algo, length: key.length * 8 };
+    const cryptParams = getCryptParams(algo, nonce, AAD);
+    return {
+      // keyLength,
+      encrypt(plaintext) {
+        bytes(plaintext);
+        return utils.encrypt(key, keyParams, cryptParams, plaintext);
       },
-      to: "0xecc19e177d24551aa7ed6bc6fe566eca726cc8a9",
-      from: "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
-      token: {
-        usd: "1.00",
-        name: "USDC",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/usdc.svg",
-        amount: "4956250000",
-        symbol: "USDC",
-        address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-        decimals: "6"
+      decrypt(ciphertext) {
+        bytes(ciphertext);
+        return utils.decrypt(key, keyParams, cryptParams, ciphertext);
       }
-    }
+    };
   };
-  return mockNotification;
 }
-function createMockNotificationERC20Received() {
-  const mockNotification = {
-    type: "erc20_received" /* ERC20_RECEIVED */,
-    id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    trigger_id: "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-    chain_id: 1,
-    block_number: 17485840,
-    block_timestamp: "2022-03-01T00:00:00Z",
-    tx_hash: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    unread: true,
-    created_at: "2022-03-01T00:00:00Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "erc20_received",
-      network_fee: {
-        gas_price: "207806259583",
-        native_token_price_in_usd: "0.83"
-      },
-      to: "0xeae7380dd4cef6fbd1144f49e4d1e6964258a4f4",
-      from: "0x51c72848c68a965f66fa7a88855f9f7784502a7f",
-      token: {
-        usd: "0.00",
-        name: "SHIBA INU",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/shib.svg",
-        amount: "8382798736999999457296646144",
-        symbol: "SHIB",
-        address: "0x95ad61b0a150d79219dcf64e1e6cc01f0b64c4ce",
-        decimals: "18"
+var cbc3 = generate(mode.CBC);
+var ctr3 = generate(mode.CTR);
+var gcm3 = generate(mode.GCM);
+
+// ../../node_modules/@noble/hashes/esm/_assert.js
+function number2(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error(`positive integer expected, not ${n}`);
+}
+function isBytes2(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+function bytes2(b, ...lengths) {
+  if (!isBytes2(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+}
+function hash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.wrapConstructor");
+  number2(h.outputLen);
+  number2(h.blockLen);
+}
+function exists2(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output2(out, instance) {
+  bytes2(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+var u322 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+var rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
+var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+}
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes3) {
+  bytes2(bytes3);
+  let hex = "";
+  for (let i = 0; i < bytes3.length; i++) {
+    hex += hexes[bytes3[i]];
+  }
+  return hex;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  bytes2(data);
+  return data;
+}
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    bytes2(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+var Hash = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+var toStr = {}.toString;
+function checkOpts(defaults, opts) {
+  if (opts !== void 0 && toStr.call(opts) !== "[object Object]")
+    throw new Error("Options should be object or undefined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/@noble/hashes/esm/hmac.js
+var HMAC = class extends Hash {
+  constructor(hash2, _key) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    hash(hash2);
+    const key = toBytes2(_key);
+    this.iHash = hash2.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash2.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash2.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    pad.fill(0);
+  }
+  update(buf) {
+    exists2(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    exists2(this);
+    bytes2(out, this.outputLen);
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to || (to = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac = (hash2, key, message) => new HMAC(hash2, key).update(message).digest();
+hmac.create = (hash2, key) => new HMAC(hash2, key);
+
+// ../../node_modules/@noble/hashes/esm/pbkdf2.js
+function pbkdf2Init(hash2, _password, _salt, _opts) {
+  hash(hash2);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  number2(c);
+  number2(dkLen);
+  number2(asyncTick);
+  if (c < 1)
+    throw new Error("PBKDF2: iterations (c) should be >= 1");
+  const password = toBytes2(_password);
+  const salt = toBytes2(_salt);
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac.create(hash2, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  u.fill(0);
+  return DK;
+}
+function pbkdf2(hash2, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash2, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = createView2(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
+// ../../node_modules/@noble/hashes/esm/_md.js
+function setBigUint642(view, byteOffset, value, isLE3) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE3);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE3 ? 4 : 0;
+  const l = isLE3 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE3);
+  view.setUint32(byteOffset + l, wl, isLE3);
+}
+var Chi = (a, b, c) => a & b ^ ~a & c;
+var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE3) {
+    super();
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE3;
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView2(this.buffer);
+  }
+  update(data) {
+    exists2(this);
+    const { view, buffer, blockLen } = this;
+    data = toBytes2(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView2(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
       }
     }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    exists2(this);
+    output2(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE3 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    this.buffer.subarray(pos).fill(0);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint642(view, blockLen - 8, BigInt(this.length * 8), isLE3);
+    this.process(view, 0);
+    const oview = createView2(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE3);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.length = length;
+    to.pos = pos;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+};
+
+// ../../node_modules/@noble/hashes/esm/sha256.js
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_IV = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor() {
+    super(64, 32, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    SHA256_W.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    this.buffer.fill(0);
+  }
+};
+var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
+// ../../node_modules/@metamask/snaps-utils/dist/chunk-5R7UF7KM.mjs
+var HandlerType = /* @__PURE__ */ ((HandlerType2) => {
+  HandlerType2["OnRpcRequest"] = "onRpcRequest";
+  HandlerType2["OnSignature"] = "onSignature";
+  HandlerType2["OnTransaction"] = "onTransaction";
+  HandlerType2["OnCronjob"] = "onCronjob";
+  HandlerType2["OnInstall"] = "onInstall";
+  HandlerType2["OnUpdate"] = "onUpdate";
+  HandlerType2["OnNameLookup"] = "onNameLookup";
+  HandlerType2["OnKeyringRequest"] = "onKeyringRequest";
+  HandlerType2["OnHomePage"] = "onHomePage";
+  HandlerType2["OnUserInput"] = "onUserInput";
+  return HandlerType2;
+})(HandlerType || {});
+var SNAP_EXPORT_NAMES = Object.values(HandlerType);
+
+// ../profile-sync-controller/src/controllers/authentication/auth-snap-requests.ts
+var snapId = "npm:@metamask/message-signing-snap";
+function createSnapSignMessageRequest(message) {
+  return {
+    snapId,
+    origin: "",
+    handler: HandlerType.OnRpcRequest,
+    request: {
+      method: "signMessage",
+      params: { message }
+    }
   };
-  return mockNotification;
 }
-function createMockNotificationERC721Sent() {
-  const mockNotification = {
-    type: "erc721_sent" /* ERC721_SENT */,
-    block_number: 18576643,
-    block_timestamp: "1700043467",
-    chain_id: 1,
-    created_at: "2023-11-15T11:08:17.895407Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      to: "0xf47f628fe3bd2595e9ab384bfffc3859b448e451",
-      nft: {
-        name: "Captainz #8680",
-        image: "https://i.seadn.io/s/raw/files/ae0fc06714ff7fb40217340d8a242c0e.gif?w=500&auto=format",
-        token_id: "8680",
-        collection: {
-          name: "The Captainz",
-          image: "https://i.seadn.io/gcs/files/6df4d75778066bce740050615bc84e21.png?w=500&auto=format",
-          symbol: "Captainz",
-          address: "0x769272677fab02575e84945f03eca517acc544cc"
-        }
-      },
-      from: "0x24a0bb54b7e7a8e406e9b28058a9fd6c49e6df4f",
-      kind: "erc721_sent",
-      network_fee: {
-        gas_price: "24550653274",
-        native_token_price_in_usd: "1986.61"
-      }
-    },
-    id: "a4193058-9814-537e-9df4-79dcac727fb6",
-    trigger_id: "028485be-b994-422b-a93b-03fcc01ab715",
-    tx_hash: "0x0833c69fb41cf972a0f031fceca242939bc3fcf82b964b74606649abcad371bd",
-    unread: true
+
+// ../profile-sync-controller/src/controllers/user-storage/index.ts
+var user_storage_exports = {};
+__export(user_storage_exports, {
+  Controller: () => UserStorageController,
+  Encryption: () => encryption_default,
+  Mocks: () => fixtures_exports,
+  createSHA256Hash: () => createSHA256Hash
+});
+
+// ../profile-sync-controller/src/controllers/user-storage/UserStorageController.ts
+import { BaseController } from "@metamask/base-controller";
+
+// ../../node_modules/@noble/hashes/esm/scrypt.js
+function XorAndSalsa(prev, pi, input, ii, out, oi) {
+  let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+  let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+  let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+  let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+  let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+  let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+  let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+  let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  for (let i = 0; i < 8; i += 2) {
+    x04 ^= rotl(x00 + x12 | 0, 7);
+    x08 ^= rotl(x04 + x00 | 0, 9);
+    x12 ^= rotl(x08 + x04 | 0, 13);
+    x00 ^= rotl(x12 + x08 | 0, 18);
+    x09 ^= rotl(x05 + x01 | 0, 7);
+    x13 ^= rotl(x09 + x05 | 0, 9);
+    x01 ^= rotl(x13 + x09 | 0, 13);
+    x05 ^= rotl(x01 + x13 | 0, 18);
+    x14 ^= rotl(x10 + x06 | 0, 7);
+    x02 ^= rotl(x14 + x10 | 0, 9);
+    x06 ^= rotl(x02 + x14 | 0, 13);
+    x10 ^= rotl(x06 + x02 | 0, 18);
+    x03 ^= rotl(x15 + x11 | 0, 7);
+    x07 ^= rotl(x03 + x15 | 0, 9);
+    x11 ^= rotl(x07 + x03 | 0, 13);
+    x15 ^= rotl(x11 + x07 | 0, 18);
+    x01 ^= rotl(x00 + x03 | 0, 7);
+    x02 ^= rotl(x01 + x00 | 0, 9);
+    x03 ^= rotl(x02 + x01 | 0, 13);
+    x00 ^= rotl(x03 + x02 | 0, 18);
+    x06 ^= rotl(x05 + x04 | 0, 7);
+    x07 ^= rotl(x06 + x05 | 0, 9);
+    x04 ^= rotl(x07 + x06 | 0, 13);
+    x05 ^= rotl(x04 + x07 | 0, 18);
+    x11 ^= rotl(x10 + x09 | 0, 7);
+    x08 ^= rotl(x11 + x10 | 0, 9);
+    x09 ^= rotl(x08 + x11 | 0, 13);
+    x10 ^= rotl(x09 + x08 | 0, 18);
+    x12 ^= rotl(x15 + x14 | 0, 7);
+    x13 ^= rotl(x12 + x15 | 0, 9);
+    x14 ^= rotl(x13 + x12 | 0, 13);
+    x15 ^= rotl(x14 + x13 | 0, 18);
+  }
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+function BlockMix(input, ii, out, oi, r) {
+  let head = oi + 0;
+  let tail = oi + 16 * r;
+  for (let i = 0; i < 16; i++)
+    out[tail + i] = input[ii + (2 * r - 1) * 16 + i];
+  for (let i = 0; i < r; i++, head += 16, ii += 16) {
+    XorAndSalsa(out, tail, input, ii, out, head);
+    if (i > 0)
+      tail += 16;
+    XorAndSalsa(out, head, input, ii += 16, out, tail);
+  }
+}
+function scryptInit(password, salt, _opts) {
+  const opts = checkOpts({
+    dkLen: 32,
+    asyncTick: 10,
+    maxmem: 1024 ** 3 + 1024
+  }, _opts);
+  const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+  number2(N);
+  number2(r);
+  number2(p);
+  number2(dkLen);
+  number2(asyncTick);
+  number2(maxmem);
+  if (onProgress !== void 0 && typeof onProgress !== "function")
+    throw new Error("progressCb should be function");
+  const blockSize = 128 * r;
+  const blockSize32 = blockSize / 4;
+  if (N <= 1 || (N & N - 1) !== 0 || N >= 2 ** (blockSize / 8) || N > 2 ** 32) {
+    throw new Error("Scrypt: N must be larger than 1, a power of 2, less than 2^(128 * r / 8) and less than 2^32");
+  }
+  if (p < 0 || p > (2 ** 32 - 1) * 32 / blockSize) {
+    throw new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
+  }
+  if (dkLen < 0 || dkLen > (2 ** 32 - 1) * 32) {
+    throw new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
+  }
+  const memUsed = blockSize * (N + p);
+  if (memUsed > maxmem) {
+    throw new Error(`Scrypt: parameters too large, ${memUsed} (128 * r * (N + p)) > ${maxmem} (maxmem)`);
+  }
+  const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+  const B32 = u322(B);
+  const V = u322(new Uint8Array(blockSize * N));
+  const tmp = u322(new Uint8Array(blockSize));
+  let blockMixCb = () => {
   };
-  return mockNotification;
+  if (onProgress) {
+    const totalBlockMix = 2 * N * p;
+    const callbackPer = Math.max(Math.floor(totalBlockMix / 1e4), 1);
+    let blockMixCnt = 0;
+    blockMixCb = () => {
+      blockMixCnt++;
+      if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+        onProgress(blockMixCnt / totalBlockMix);
+    };
+  }
+  return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
 }
-function createMockNotificationERC721Received() {
-  const mockNotification = {
-    type: "erc721_received" /* ERC721_RECEIVED */,
-    block_number: 18571446,
-    block_timestamp: "1699980623",
-    chain_id: 1,
-    created_at: "2023-11-14T17:40:52.319281Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      to: "0xba7f3daa8adfdad686574406ab9bd5d2f0a49d2e",
-      nft: {
-        name: "The Plague #2722",
-        image: "https://i.seadn.io/s/raw/files/a96f90ec8ebf55a2300c66a0c46d6a16.png?w=500&auto=format",
-        token_id: "2722",
-        collection: {
-          name: "The Plague NFT",
-          image: "https://i.seadn.io/gcs/files/4577987a5ca45ca5118b2e31559ee4d1.jpg?w=500&auto=format",
-          symbol: "FROG",
-          address: "0xc379e535caff250a01caa6c3724ed1359fe5c29b"
-        }
-      },
-      from: "0x24a0bb54b7e7a8e406e9b28058a9fd6c49e6df4f",
-      kind: "erc721_received",
-      network_fee: {
-        gas_price: "53701898538",
-        native_token_price_in_usd: "2047.01"
-      }
-    },
-    id: "00a79d24-befa-57ed-a55a-9eb8696e1654",
-    trigger_id: "d24ac26a-8579-49ec-9947-d04d63592ebd",
-    tx_hash: "0xe554c9e29e6eeca8ba94da4d047334ba08b8eb9ca3b801dd69cec08dfdd4ae43",
-    unread: true
+function scryptOutput(password, dkLen, B, V, tmp) {
+  const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+  B.fill(0);
+  V.fill(0);
+  tmp.fill(0);
+  return res;
+}
+function scrypt(password, salt, opts) {
+  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+  if (!isLE2)
+    byteSwap32(B32);
+  for (let pi = 0; pi < p; pi++) {
+    const Pi = blockSize32 * pi;
+    for (let i = 0; i < blockSize32; i++)
+      V[i] = B32[Pi + i];
+    for (let i = 0, pos = 0; i < N - 1; i++) {
+      BlockMix(V, pos, V, pos += blockSize32, r);
+      blockMixCb();
+    }
+    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
+    blockMixCb();
+    for (let i = 0; i < N; i++) {
+      const j = B32[Pi + blockSize32 - 16] % N;
+      for (let k = 0; k < blockSize32; k++)
+        tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
+      BlockMix(tmp, 0, B32, Pi, r);
+      blockMixCb();
+    }
+  }
+  if (!isLE2)
+    byteSwap32(B32);
+  return scryptOutput(password, dkLen, B, V, tmp);
+}
+
+// ../profile-sync-controller/src/controllers/user-storage/encryption/utils.ts
+var byteArrayToBase64 = (byteArray) => {
+  return Buffer.from(byteArray).toString("base64");
+};
+var base64ToByteArray = (base64) => {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+};
+var bytesToUtf8 = (byteArray) => {
+  const decoder = new TextDecoder("utf-8");
+  return decoder.decode(byteArray);
+};
+
+// ../profile-sync-controller/src/controllers/user-storage/encryption/cache.ts
+var MAX_PASSWORD_CACHES = 3;
+var MAX_SALT_CACHES = 10;
+var inMemCachedKDF = {};
+var getPasswordCache = (hashedPassword) => {
+  inMemCachedKDF[hashedPassword] ?? (inMemCachedKDF[hashedPassword] = /* @__PURE__ */ new Map());
+  return inMemCachedKDF[hashedPassword];
+};
+function getCachedKeyBySalt(hashedPassword, salt) {
+  const cache = getPasswordCache(hashedPassword);
+  const base64Salt = byteArrayToBase64(salt);
+  const cachedKey = cache.get(base64Salt);
+  if (!cachedKey) {
+    return void 0;
+  }
+  return {
+    salt,
+    base64Salt,
+    key: cachedKey
   };
-  return mockNotification;
 }
-function createMockNotificationERC1155Sent() {
-  const mockNotification = {
-    type: "erc1155_sent" /* ERC1155_SENT */,
-    block_number: 18615206,
-    block_timestamp: "1700510003",
-    chain_id: 1,
-    created_at: "2023-11-20T20:44:10.110706Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      to: "0x15bd77ccacf2da39b84f0c31fee2e451225bb190",
-      nft: {
-        name: "IlluminatiNFT DAO",
-        image: "https://i.seadn.io/gcs/files/79a77cb37c7b2f1069f752645d29fea7.jpg?w=500&auto=format",
-        token_id: "1",
-        collection: {
-          name: "IlluminatiNFT DAO",
-          image: "https://i.seadn.io/gae/LTKz3om2eCQfn3M6PkqEmY7KhLtdMCOm0QVch2318KJq7-KyToCH7NBTMo4UuJ0AZI-oaBh1HcgrAEIEWYbXY3uMcYpuGXunaXEh?w=500&auto=format",
-          symbol: "TRUTH",
-          address: "0xe25f0fe686477f9df3c2876c4902d3b85f75f33a"
-        }
-      },
-      from: "0x0000000000000000000000000000000000000000",
-      kind: "erc1155_sent",
-      network_fee: {
-        gas_price: "33571446596",
-        native_token_price_in_usd: "2038.88"
-      }
-    },
-    id: "a09ff9d1-623a-52ab-a3d4-c7c8c9a58362",
-    trigger_id: "e2130f7d-78b8-4c34-999a-3f3d3bb5b03c",
-    tx_hash: "0x03381aba290facbaf71c123e263c8dc3dd550aac00ef589cce395182eaeff76f",
-    unread: true
+function getAnyCachedKey(hashedPassword) {
+  const cache = getPasswordCache(hashedPassword);
+  const cachedEntry = cache.entries().next().value;
+  if (!cachedEntry) {
+    return void 0;
+  }
+  const base64Salt = cachedEntry[0];
+  const bytesSalt = base64ToByteArray(base64Salt);
+  return {
+    salt: bytesSalt,
+    base64Salt,
+    key: cachedEntry[1]
   };
-  return mockNotification;
 }
-function createMockNotificationERC1155Received() {
-  const mockNotification = {
-    type: "erc1155_received" /* ERC1155_RECEIVED */,
-    block_number: 18615206,
-    block_timestamp: "1700510003",
-    chain_id: 1,
-    created_at: "2023-11-20T20:44:10.110706Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      to: "0x15bd77ccacf2da39b84f0c31fee2e451225bb190",
-      nft: {
-        name: "IlluminatiNFT DAO",
-        image: "https://i.seadn.io/gcs/files/79a77cb37c7b2f1069f752645d29fea7.jpg?w=500&auto=format",
-        token_id: "1",
-        collection: {
-          name: "IlluminatiNFT DAO",
-          image: "https://i.seadn.io/gae/LTKz3om2eCQfn3M6PkqEmY7KhLtdMCOm0QVch2318KJq7-KyToCH7NBTMo4UuJ0AZI-oaBh1HcgrAEIEWYbXY3uMcYpuGXunaXEh?w=500&auto=format",
-          symbol: "TRUTH",
-          address: "0xe25f0fe686477f9df3c2876c4902d3b85f75f33a"
+function setCachedKey(hashedPassword, salt, key) {
+  if (Object.keys(inMemCachedKDF).length > MAX_PASSWORD_CACHES) {
+    inMemCachedKDF = {};
+  }
+  const cache = getPasswordCache(hashedPassword);
+  const base64Salt = byteArrayToBase64(salt);
+  if (cache.size > MAX_SALT_CACHES) {
+    cache.clear();
+  }
+  cache.set(base64Salt, key);
+}
+
+// ../profile-sync-controller/src/controllers/user-storage/encryption/encryption.ts
+var ALGORITHM_NONCE_SIZE = 12;
+var ALGORITHM_KEY_SIZE = 16;
+var SCRYPT_SALT_SIZE = 16;
+var SCRYPT_N = 2 ** 17;
+var SCRYPT_r = 8;
+var SCRYPT_p = 1;
+var _encryptStringV1, encryptStringV1_fn, _decryptStringV1, decryptStringV1_fn, _encrypt, encrypt_fn, _decrypt, decrypt_fn, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn;
+var EncryptorDecryptor = class {
+  constructor() {
+    __privateAdd(this, _encryptStringV1);
+    __privateAdd(this, _decryptStringV1);
+    __privateAdd(this, _encrypt);
+    __privateAdd(this, _decrypt);
+    __privateAdd(this, _getOrGenerateScryptKey);
+  }
+  encryptString(plaintext, password) {
+    try {
+      return __privateMethod(this, _encryptStringV1, encryptStringV1_fn).call(this, plaintext, password);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(`Unable to encrypt string - ${errorMessage}`);
+    }
+  }
+  decryptString(encryptedDataStr, password) {
+    try {
+      const encryptedData = JSON.parse(encryptedDataStr);
+      if (encryptedData.v === "1") {
+        if (encryptedData.t === "scrypt") {
+          return __privateMethod(this, _decryptStringV1, decryptStringV1_fn).call(this, encryptedData, password);
         }
-      },
-      from: "0x0000000000000000000000000000000000000000",
-      kind: "erc1155_received",
-      network_fee: {
-        gas_price: "33571446596",
-        native_token_price_in_usd: "2038.88"
       }
+      throw new Error(
+        `Unsupported encrypted data payload - ${encryptedDataStr}`
+      );
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(`Unable to decrypt string - ${errorMessage}`);
+    }
+  }
+};
+_encryptStringV1 = new WeakSet();
+encryptStringV1_fn = function(plaintext, password) {
+  const { key, salt } = __privateMethod(this, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn).call(this, password, {
+    N: SCRYPT_N,
+    r: SCRYPT_r,
+    p: SCRYPT_p,
+    dkLen: ALGORITHM_KEY_SIZE
+  });
+  const plaintextRaw = utf8ToBytes2(plaintext);
+  const ciphertextAndNonceAndSalt = concatBytes(
+    salt,
+    __privateMethod(this, _encrypt, encrypt_fn).call(this, plaintextRaw, key)
+  );
+  const encryptedData = byteArrayToBase64(ciphertextAndNonceAndSalt);
+  const encryptedPayload = {
+    v: "1",
+    t: "scrypt",
+    d: encryptedData,
+    o: {
+      N: SCRYPT_N,
+      r: SCRYPT_r,
+      p: SCRYPT_p,
+      dkLen: ALGORITHM_KEY_SIZE
     },
-    id: "b6b93c84-e8dc-54ed-9396-7ea50474843a",
-    trigger_id: "710c8abb-43a9-42a5-9d86-9dd258726c82",
-    tx_hash: "0x03381aba290facbaf71c123e263c8dc3dd550aac00ef589cce395182eaeff76f",
-    unread: true
+    saltLen: SCRYPT_SALT_SIZE
   };
-  return mockNotification;
-}
-function createMockNotificationMetaMaskSwapsCompleted() {
-  const mockNotification = {
-    type: "metamask_swap_completed" /* METAMASK_SWAP_COMPLETED */,
-    block_number: 18377666,
-    block_timestamp: "1697637275",
-    chain_id: 1,
-    created_at: "2023-10-18T13:58:49.854596Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "metamask_swap_completed",
-      rate: "1558.27",
-      token_in: {
-        usd: "1576.73",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "9000000000000000",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18",
-        name: "Ethereum"
-      },
-      token_out: {
-        usd: "1.00",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/usdt.svg",
-        amount: "14024419",
-        symbol: "USDT",
-        address: "0xdac17f958d2ee523a2206206994597c13d831ec7",
-        decimals: "6",
-        name: "USDT"
-      },
-      network_fee: {
-        gas_price: "15406129273",
-        native_token_price_in_usd: "1576.73"
-      }
-    },
-    id: "7ddfe6a1-ac52-5ffe-aa40-f04242db4b8b",
-    trigger_id: "d2eaa2eb-2e6e-4fd5-8763-b70ea571b46c",
-    tx_hash: "0xf69074290f3aa11bce567aabc9ca0df7a12559dfae1b80ba1a124e9dfe19ecc5",
-    unread: true
+  return JSON.stringify(encryptedPayload);
+};
+_decryptStringV1 = new WeakSet();
+decryptStringV1_fn = function(data, password) {
+  const { o, d: base64CiphertextAndNonceAndSalt, saltLen } = data;
+  const ciphertextAndNonceAndSalt = base64ToByteArray(
+    base64CiphertextAndNonceAndSalt
+  );
+  const salt = ciphertextAndNonceAndSalt.slice(0, saltLen);
+  const ciphertextAndNonce = ciphertextAndNonceAndSalt.slice(
+    saltLen,
+    ciphertextAndNonceAndSalt.length
+  );
+  const { key } = __privateMethod(this, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn).call(this, password, {
+    N: o.N,
+    r: o.r,
+    p: o.p,
+    dkLen: o.dkLen
+  }, salt);
+  return bytesToUtf8(__privateMethod(this, _decrypt, decrypt_fn).call(this, ciphertextAndNonce, key));
+};
+_encrypt = new WeakSet();
+encrypt_fn = function(plaintext, key) {
+  const nonce = randomBytes(ALGORITHM_NONCE_SIZE);
+  const ciphertext = gcm(key, nonce).encrypt(plaintext);
+  return concatBytes(nonce, ciphertext);
+};
+_decrypt = new WeakSet();
+decrypt_fn = function(ciphertextAndNonce, key) {
+  const nonce = ciphertextAndNonce.slice(0, ALGORITHM_NONCE_SIZE);
+  const ciphertext = ciphertextAndNonce.slice(
+    ALGORITHM_NONCE_SIZE,
+    ciphertextAndNonce.length
+  );
+  return gcm(key, nonce).decrypt(ciphertext);
+};
+_getOrGenerateScryptKey = new WeakSet();
+getOrGenerateScryptKey_fn = function(password, o, salt) {
+  const hashedPassword = createSHA256Hash(password);
+  const cachedKey = salt ? getCachedKeyBySalt(hashedPassword, salt) : getAnyCachedKey(hashedPassword);
+  if (cachedKey) {
+    return {
+      key: cachedKey.key,
+      salt: cachedKey.salt
+    };
+  }
+  const newSalt = salt ?? randomBytes(SCRYPT_SALT_SIZE);
+  const newKey = scrypt(password, newSalt, {
+    N: o.N,
+    r: o.r,
+    p: o.p,
+    dkLen: o.dkLen
+  });
+  setCachedKey(hashedPassword, newSalt, newKey);
+  return {
+    key: newKey,
+    salt: newSalt
   };
-  return mockNotification;
+};
+var encryption = new EncryptorDecryptor();
+var encryption_default = encryption;
+function createSHA256Hash(data) {
+  const hashedData = sha256(data);
+  return bytesToHex(hashedData);
 }
-function createMockNotificationRocketPoolStakeCompleted() {
-  const mockNotification = {
-    type: "rocketpool_stake_completed" /* ROCKETPOOL_STAKE_COMPLETED */,
-    block_number: 18585057,
-    block_timestamp: "1700145059",
-    chain_id: 1,
-    created_at: "2023-11-20T12:02:48.796824Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "rocketpool_stake_completed",
-      stake_in: {
-        usd: "2031.86",
-        name: "Ethereum",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "190690478063438272",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18"
-      },
-      stake_out: {
-        usd: "2226.49",
-        name: "Rocket Pool ETH",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/rETH.svg",
-        amount: "175024360778165879",
-        symbol: "RETH",
-        address: "0xae78736Cd615f374D3085123A210448E74Fc6393",
-        decimals: "18"
-      },
-      network_fee: {
-        gas_price: "36000000000",
-        native_token_price_in_usd: "2031.86"
-      }
-    },
-    id: "c2a2f225-b2fb-5d6c-ba56-e27a5c71ffb9",
-    trigger_id: "5110ff97-acff-40c0-83b4-11d487b8c7b0",
-    tx_hash: "0xcfc0693bf47995907b0f46ef0644cf16dd9a0de797099b2e00fd481e1b2117d3",
-    unread: true
-  };
-  return mockNotification;
+
+// ../profile-sync-controller/src/controllers/user-storage/encryption/index.ts
+var encryption_default2 = encryption_default;
+
+// ../profile-sync-controller/src/controllers/user-storage/services.ts
+import log from "loglevel";
+
+// ../profile-sync-controller/src/controllers/user-storage/schema.ts
+var USER_STORAGE_ENTRIES = {
+  notificationSettings: {
+    path: "notifications",
+    entryName: "notificationSettings"
+  }
+};
+function createEntryPath(entryKey, storageKey) {
+  const entry = USER_STORAGE_ENTRIES[entryKey];
+  if (!entry) {
+    throw new Error(`user-storage - invalid entry provided: ${entryKey}`);
+  }
+  const hashedKey = createSHA256Hash(entry.entryName + storageKey);
+  return `/${entry.path}/${hashedKey}`;
 }
-function createMockNotificationRocketPoolUnStakeCompleted() {
-  const mockNotification = {
-    type: "rocketpool_unstake_completed" /* ROCKETPOOL_UNSTAKE_COMPLETED */,
-    block_number: 18384336,
-    block_timestamp: "1697718011",
-    chain_id: 1,
-    created_at: "2023-10-19T13:11:10.623042Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "rocketpool_unstake_completed",
-      stake_in: {
-        usd: "1686.34",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/rETH.svg",
-        amount: "66608041413696770",
-        symbol: "RETH",
-        address: "0xae78736Cd615f374D3085123A210448E74Fc6393",
-        decimals: "18",
-        name: "Rocketpool Eth"
-      },
-      stake_out: {
-        usd: "1553.75",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "72387843427700824",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18",
-        name: "Ethereum"
-      },
-      network_fee: {
-        gas_price: "5656322987",
-        native_token_price_in_usd: "1553.75"
+
+// ../profile-sync-controller/src/controllers/user-storage/services.ts
+var ENV_URLS2 = getEnvUrls("prd" /* PRD */);
+var USER_STORAGE_API = ENV_URLS2.userStorageApiUrl;
+var USER_STORAGE_ENDPOINT = `${USER_STORAGE_API}/api/v1/userstorage`;
+async function getUserStorage(opts) {
+  try {
+    const path = createEntryPath(opts.entryKey, opts.storageKey);
+    const url = new URL(`${USER_STORAGE_ENDPOINT}${path}`);
+    const userStorageResponse = await fetch(url.toString(), {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${opts.bearerToken}`
       }
+    });
+    if (userStorageResponse.status === 404) {
+      return null;
+    }
+    if (userStorageResponse.status !== 200) {
+      throw new Error("Unable to get User Storage");
+    }
+    const userStorage = await userStorageResponse.json();
+    const encryptedData = userStorage?.Data ?? null;
+    if (!encryptedData) {
+      return null;
+    }
+    const decryptedData = encryption_default2.decryptString(
+      encryptedData,
+      opts.storageKey
+    );
+    return decryptedData;
+  } catch (e) {
+    log.error("Failed to get user storage", e);
+    return null;
+  }
+}
+async function upsertUserStorage(data, opts) {
+  const encryptedData = encryption_default2.encryptString(data, opts.storageKey);
+  const path = createEntryPath(opts.entryKey, opts.storageKey);
+  const url = new URL(`${USER_STORAGE_ENDPOINT}${path}`);
+  const res = await fetch(url.toString(), {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${opts.bearerToken}`
     },
-    id: "d8c246e7-a0a4-5f1d-b079-2b1707665fbc",
-    trigger_id: "291ec897-f569-4837-b6c0-21001b198dff",
-    tx_hash: "0xc7972a7e409abfc62590ec90e633acd70b9b74e76ad02305be8bf133a0e22d5f",
-    unread: true
-  };
-  return mockNotification;
+    body: JSON.stringify({ data: encryptedData })
+  });
+  if (!res.ok) {
+    throw new Error("user-storage - unable to upsert data");
+  }
 }
-function createMockNotificationLidoStakeCompleted() {
-  const mockNotification = {
-    type: "lido_stake_completed" /* LIDO_STAKE_COMPLETED */,
-    block_number: 18487118,
-    block_timestamp: "1698961091",
-    chain_id: 1,
-    created_at: "2023-11-02T22:28:49.970865Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "lido_stake_completed",
-      stake_in: {
-        usd: "1806.33",
-        name: "Ethereum",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "330303634023928032",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18"
+
+// ../profile-sync-controller/src/controllers/user-storage/UserStorageController.ts
+var controllerName = "UserStorageController";
+var defaultState = {
+  isProfileSyncingEnabled: true,
+  isProfileSyncingUpdateLoading: false
+};
+var metadata = {
+  isProfileSyncingEnabled: {
+    persist: true,
+    anonymous: true
+  },
+  isProfileSyncingUpdateLoading: {
+    persist: false,
+    anonymous: false
+  }
+};
+var _auth, _notificationServices, _registerMessageHandlers, registerMessageHandlers_fn, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn, _createStorageKey, createStorageKey_fn, _snapSignMessage, snapSignMessage_fn, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn;
+var UserStorageController = class extends BaseController {
+  constructor(params) {
+    super({
+      messenger: params.messenger,
+      metadata,
+      name: controllerName,
+      state: { ...defaultState, ...params.state }
+    });
+    /**
+     * Constructor helper for registering this controller's messaging system
+     * actions.
+     */
+    __privateAdd(this, _registerMessageHandlers);
+    __privateAdd(this, _assertProfileSyncingEnabled);
+    /**
+     * Utility to get the bearer token and storage key
+     */
+    __privateAdd(this, _getStorageKeyAndBearerToken);
+    /**
+     * Rather than storing the storage key, we can compute the storage key when needed.
+     *
+     * @returns the storage key
+     */
+    __privateAdd(this, _createStorageKey);
+    /**
+     * Signs a specific message using an underlying auth snap.
+     *
+     * @param message - A specific tagged message to sign.
+     * @returns A Signature created by the snap.
+     */
+    __privateAdd(this, _snapSignMessage);
+    __privateAdd(this, _setIsProfileSyncingUpdateLoading);
+    __privateAdd(this, _auth, {
+      getBearerToken: async () => {
+        return await this.messagingSystem.call(
+          "AuthenticationController:getBearerToken"
+        );
       },
-      stake_out: {
-        usd: "1801.30",
-        name: "Liquid staked Ether 2.0",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
-        amount: "330303634023928032",
-        symbol: "STETH",
-        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
-        decimals: "18"
+      getProfileId: async () => {
+        const sessionProfile = await this.messagingSystem.call(
+          "AuthenticationController:getSessionProfile"
+        );
+        return sessionProfile?.profileId;
       },
-      network_fee: {
-        gas_price: "26536359866",
-        native_token_price_in_usd: "1806.33"
-      }
-    },
-    id: "9d9b1467-b3ee-5492-8ca2-22382657b690",
-    trigger_id: "ec10d66a-f78f-461f-83c9-609aada8cc50",
-    tx_hash: "0x8cc0fa805f7c3b1743b14f3b91c6b824113b094f26d4ccaf6a71ad8547ce6a0f",
-    unread: true
-  };
-  return mockNotification;
-}
-function createMockNotificationLidoWithdrawalRequested() {
-  const mockNotification = {
-    type: "lido_withdrawal_requested" /* LIDO_WITHDRAWAL_REQUESTED */,
-    block_number: 18377760,
-    block_timestamp: "1697638415",
-    chain_id: 1,
-    created_at: "2023-10-18T15:04:02.482526Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "lido_withdrawal_requested",
-      stake_in: {
-        usd: "1568.54",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
-        amount: "97180668792218669859",
-        symbol: "STETH",
-        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
-        decimals: "18",
-        name: "Staked Eth"
+      isAuthEnabled: () => {
+        return this.messagingSystem.call("AuthenticationController:isSignedIn");
       },
-      stake_out: {
-        usd: "1576.73",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "97180668792218669859",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18",
-        name: "Ethereum"
+      signIn: async () => {
+        return await this.messagingSystem.call(
+          "AuthenticationController:performSignIn"
+        );
       },
-      network_fee: {
-        gas_price: "11658906980",
-        native_token_price_in_usd: "1576.73"
+      signOut: async () => {
+        return this.messagingSystem.call(
+          "AuthenticationController:performSignOut"
+        );
       }
-    },
-    id: "29ddc718-78c6-5f91-936f-2bef13a605f0",
-    trigger_id: "ef003925-3379-4ba7-9e2d-8218690cadc8",
-    tx_hash: "0x58b5f82e084cb750ea174e02b20fbdfd2ba8d78053deac787f34fc38e5d427aa",
-    unread: true
-  };
-  return mockNotification;
-}
-function createMockNotificationLidoWithdrawalCompleted() {
-  const mockNotification = {
-    type: "lido_withdrawal_completed" /* LIDO_WITHDRAWAL_COMPLETED */,
-    block_number: 18378208,
-    block_timestamp: "1697643851",
-    chain_id: 1,
-    created_at: "2023-10-18T16:35:03.147606Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "lido_withdrawal_completed",
-      stake_in: {
-        usd: "1570.23",
-        image: "https://raw.githubusercontent.com/MetaMask/contract-metadata/master/images/stETH.svg",
-        amount: "35081997661451346",
-        symbol: "STETH",
-        address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
-        decimals: "18",
-        name: "Staked Eth"
-      },
-      stake_out: {
-        usd: "1571.74",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        amount: "35081997661451346",
-        symbol: "ETH",
-        address: "0x0000000000000000000000000000000000000000",
-        decimals: "18",
-        name: "Ethereum"
+    });
+    __privateAdd(this, _notificationServices, {
+      disableNotificationServices: async () => {
+        return await this.messagingSystem.call(
+          "NotificationServicesController:disableNotificationServices"
+        );
       },
-      network_fee: {
-        gas_price: "12699495150",
-        native_token_price_in_usd: "1571.74"
+      selectIsNotificationServicesEnabled: async () => {
+        return this.messagingSystem.call(
+          "NotificationServicesController:selectIsNotificationServicesEnabled"
+        );
       }
-    },
-    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
-    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
-    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
-    unread: true
-  };
-  return mockNotification;
-}
-function createMockNotificationLidoReadyToBeWithdrawn() {
-  const mockNotification = {
-    type: "lido_stake_ready_to_be_withdrawn" /* LIDO_STAKE_READY_TO_BE_WITHDRAWN */,
-    block_number: 18378208,
-    block_timestamp: "1697643851",
-    chain_id: 1,
-    created_at: "2023-10-18T16:35:03.147606Z",
-    address: "0x881D40237659C251811CEC9c364ef91dC08D300C",
-    data: {
-      kind: "lido_stake_ready_to_be_withdrawn",
-      request_id: "123456789",
-      staked_eth: {
-        address: "0x881D40237659C251811CEC9c364ef91dC08D300F",
-        symbol: "ETH",
-        name: "Ethereum",
-        amount: "2.5",
-        decimals: "18",
-        image: "https://token.api.cx.metamask.io/assets/nativeCurrencyLogos/ethereum.svg",
-        usd: "10000.00"
+    });
+    this.getMetaMetricsState = params.getMetaMetricsState;
+    __privateMethod(this, _registerMessageHandlers, registerMessageHandlers_fn).call(this);
+  }
+  async enableProfileSyncing() {
+    try {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, true);
+      const authEnabled = __privateGet(this, _auth).isAuthEnabled();
+      if (!authEnabled) {
+        await __privateGet(this, _auth).signIn();
       }
-    },
-    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
-    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
-    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
-    unread: true
-  };
-  return mockNotification;
-}
-function createMockRawOnChainNotifications() {
-  return [1, 2, 3].map((id) => {
-    const notification = createMockNotificationEthSent();
-    notification.id += `-${id}`;
-    return notification;
-  });
-}
-
-// src/NotificationServicesController/__fixtures__/mockResponses.ts
-var CONTENTFUL_RESPONSE = createMockFeatureAnnouncementAPIResult();
-var getMockFeatureAnnouncementResponse = () => {
-  return {
-    url: FEATURE_ANNOUNCEMENT_API,
-    requestMethod: "GET",
-    response: CONTENTFUL_RESPONSE
-  };
+      this.update((state) => {
+        state.isProfileSyncingEnabled = true;
+      });
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+    } catch (e) {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(
+        `${controllerName} - failed to enable profile syncing - ${errorMessage}`
+      );
+    }
+  }
+  async setIsProfileSyncingEnabled(isProfileSyncingEnabled) {
+    this.update((state) => {
+      state.isProfileSyncingEnabled = isProfileSyncingEnabled;
+    });
+  }
+  async disableProfileSyncing() {
+    const isAlreadyDisabled = !this.state.isProfileSyncingEnabled;
+    if (isAlreadyDisabled) {
+      return;
+    }
+    try {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, true);
+      const isNotificationServicesEnabled = await __privateGet(this, _notificationServices).selectIsNotificationServicesEnabled();
+      if (isNotificationServicesEnabled) {
+        await __privateGet(this, _notificationServices).disableNotificationServices();
+      }
+      const isMetaMetricsParticipation = this.getMetaMetricsState();
+      if (!isMetaMetricsParticipation) {
+        this.messagingSystem.call("AuthenticationController:performSignOut");
+      }
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      this.update((state) => {
+        state.isProfileSyncingEnabled = false;
+      });
+    } catch (e) {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(
+        `${controllerName} - failed to disable profile syncing - ${errorMessage}`
+      );
+    }
+  }
+  /**
+   * Allows retrieval of stored data. Data stored is string formatted.
+   * Developers can extend the entry path and entry name through the `schema.ts` file.
+   *
+   * @param entryKey - entry key that matches schema
+   * @returns the decrypted string contents found from user storage (or null if not found)
+   */
+  async performGetStorage(entryKey) {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const { bearerToken, storageKey } = await __privateMethod(this, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn).call(this);
+    const result = await getUserStorage({
+      entryKey,
+      bearerToken,
+      storageKey
+    });
+    return result;
+  }
+  /**
+   * Allows storage of user data. Data stored must be string formatted.
+   * Developers can extend the entry path and entry name through the `schema.ts` file.
+   *
+   * @param entryKey - entry key that matches schema
+   * @param value - The string data you want to store.
+   * @returns nothing. NOTE that an error is thrown if fails to store data.
+   */
+  async performSetStorage(entryKey, value) {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const { bearerToken, storageKey } = await __privateMethod(this, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn).call(this);
+    await upsertUserStorage(value, {
+      entryKey,
+      bearerToken,
+      storageKey
+    });
+  }
+  /**
+   * Retrieves the storage key, for internal use only!
+   *
+   * @returns the storage key
+   */
+  async getStorageKey() {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const storageKey = await __privateMethod(this, _createStorageKey, createStorageKey_fn).call(this);
+    return storageKey;
+  }
 };
-var getMockBatchCreateTriggersResponse = () => {
-  return {
-    url: TRIGGER_API_BATCH_ENDPOINT,
-    requestMethod: "POST",
-    response: null
-  };
+_auth = new WeakMap();
+_notificationServices = new WeakMap();
+_registerMessageHandlers = new WeakSet();
+registerMessageHandlers_fn = function() {
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:performGetStorage",
+    this.performGetStorage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:performSetStorage",
+    this.performSetStorage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:getStorageKey",
+    this.getStorageKey.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:enableProfileSyncing",
+    this.enableProfileSyncing.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:disableProfileSyncing",
+    this.disableProfileSyncing.bind(this)
+  );
 };
-var getMockBatchDeleteTriggersResponse = () => {
-  return {
-    url: TRIGGER_API_BATCH_ENDPOINT,
-    requestMethod: "DELETE",
-    response: null
-  };
+_assertProfileSyncingEnabled = new WeakSet();
+assertProfileSyncingEnabled_fn = function() {
+  if (!this.state.isProfileSyncingEnabled) {
+    throw new Error(
+      `${controllerName}: Unable to call method, user is not authenticated`
+    );
+  }
 };
-var MOCK_RAW_ON_CHAIN_NOTIFICATIONS = createMockRawOnChainNotifications();
-var getMockListNotificationsResponse = () => {
+_getStorageKeyAndBearerToken = new WeakSet();
+getStorageKeyAndBearerToken_fn = async function() {
+  const bearerToken = await __privateGet(this, _auth).getBearerToken();
+  if (!bearerToken) {
+    throw new Error("UserStorageController - unable to get bearer token");
+  }
+  const storageKey = await __privateMethod(this, _createStorageKey, createStorageKey_fn).call(this);
+  return { bearerToken, storageKey };
+};
+_createStorageKey = new WeakSet();
+createStorageKey_fn = async function() {
+  const id = await __privateGet(this, _auth).getProfileId();
+  if (!id) {
+    throw new Error("UserStorageController - unable to create storage key");
+  }
+  const storageKeySignature = await __privateMethod(this, _snapSignMessage, snapSignMessage_fn).call(this, `metamask:${id}`);
+  const storageKey = createSHA256Hash(storageKeySignature);
+  return storageKey;
+};
+_snapSignMessage = new WeakSet();
+snapSignMessage_fn = function(message) {
+  return this.messagingSystem.call(
+    "SnapController:handleRequest",
+    createSnapSignMessageRequest(message)
+  );
+};
+_setIsProfileSyncingUpdateLoading = new WeakSet();
+setIsProfileSyncingUpdateLoading_fn = function(isProfileSyncingUpdateLoading) {
+  this.update((state) => {
+    state.isProfileSyncingUpdateLoading = isProfileSyncingUpdateLoading;
+  });
+};
+
+// ../profile-sync-controller/src/controllers/user-storage/__fixtures__/index.ts
+var fixtures_exports = {};
+__export(fixtures_exports, {
+  MOCK_ENCRYPTED_STORAGE_DATA: () => MOCK_ENCRYPTED_STORAGE_DATA,
+  MOCK_STORAGE_DATA: () => MOCK_STORAGE_DATA,
+  MOCK_STORAGE_KEY: () => MOCK_STORAGE_KEY,
+  MOCK_STORAGE_KEY_SIGNATURE: () => MOCK_STORAGE_KEY_SIGNATURE,
+  MOCK_USER_STORAGE_NOTIFICATIONS_ENDPOINT: () => MOCK_USER_STORAGE_NOTIFICATIONS_ENDPOINT,
+  getMockUserStorageGetResponse: () => getMockUserStorageGetResponse,
+  getMockUserStoragePutResponse: () => getMockUserStoragePutResponse,
+  mockEndpointGetUserStorage: () => mockEndpointGetUserStorage,
+  mockEndpointUpsertUserStorage: () => mockEndpointUpsertUserStorage
+});
+
+// ../profile-sync-controller/src/controllers/user-storage/__fixtures__/mockStorage.ts
+var MOCK_STORAGE_KEY_SIGNATURE = "mockStorageKey";
+var MOCK_STORAGE_KEY = createSHA256Hash(MOCK_STORAGE_KEY_SIGNATURE);
+var MOCK_STORAGE_DATA = JSON.stringify({ hello: "world" });
+var MOCK_ENCRYPTED_STORAGE_DATA = encryption_default2.encryptString(
+  MOCK_STORAGE_DATA,
+  MOCK_STORAGE_KEY
+);
+
+// ../profile-sync-controller/src/controllers/user-storage/__fixtures__/mockResponses.ts
+var MOCK_USER_STORAGE_NOTIFICATIONS_ENDPOINT = `${USER_STORAGE_ENDPOINT}${createEntryPath(
+  "notificationSettings",
+  MOCK_STORAGE_KEY
+)}`;
+var MOCK_GET_USER_STORAGE_RESPONSE = {
+  HashedKey: "HASHED_KEY",
+  Data: MOCK_ENCRYPTED_STORAGE_DATA
+};
+var getMockUserStorageGetResponse = () => {
   return {
-    url: NOTIFICATION_API_LIST_ENDPOINT,
-    requestMethod: "POST",
-    response: MOCK_RAW_ON_CHAIN_NOTIFICATIONS
+    url: MOCK_USER_STORAGE_NOTIFICATIONS_ENDPOINT,
+    requestMethod: "GET",
+    response: MOCK_GET_USER_STORAGE_RESPONSE
   };
 };
-var getMockMarkNotificationsAsReadResponse = () => {
+var getMockUserStoragePutResponse = () => {
   return {
-    url: NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT,
-    requestMethod: "POST",
+    url: MOCK_USER_STORAGE_NOTIFICATIONS_ENDPOINT,
+    requestMethod: "PUT",
     response: null
   };
 };
 
-// src/NotificationServicesController/__fixtures__/mockServices.ts
+// ../profile-sync-controller/src/controllers/user-storage/__fixtures__/mockServices.ts
 var import_nock = __toESM(require_nock());
-var mockFetchFeatureAnnouncementNotifications = (mockReply) => {
-  const mockResponse = getMockFeatureAnnouncementResponse();
-  const reply = mockReply ?? { status: 200, body: mockResponse.response };
-  const mockEndpoint = (0, import_nock.default)(mockResponse.url).get("").query(true).reply(reply.status, reply.body);
-  return mockEndpoint;
-};
-var mockBatchCreateTriggers = (mockReply) => {
-  const mockResponse = getMockBatchCreateTriggersResponse();
-  const reply = mockReply ?? { status: 204 };
-  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").reply(reply.status, reply.body);
-  return mockEndpoint;
-};
-var mockBatchDeleteTriggers = (mockReply) => {
-  const mockResponse = getMockBatchDeleteTriggersResponse();
-  const reply = mockReply ?? { status: 204 };
-  const mockEndpoint = (0, import_nock.default)(mockResponse.url).delete("").reply(reply.status, reply.body);
-  return mockEndpoint;
-};
-var mockListNotifications = (mockReply) => {
-  const mockResponse = getMockListNotificationsResponse();
-  const reply = mockReply ?? { status: 200, body: mockResponse.response };
-  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").query(true).reply(reply.status, reply.body);
+var mockEndpointGetUserStorage = (mockReply) => {
+  const mockResponse = getMockUserStorageGetResponse();
+  const reply = mockReply ?? {
+    status: 200,
+    body: mockResponse.response
+  };
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).get("").reply(reply.status, reply.body);
   return mockEndpoint;
 };
-var mockMarkNotificationsAsRead = (mockReply) => {
-  const mockResponse = getMockMarkNotificationsAsReadResponse();
-  const reply = mockReply ?? { status: 200 };
-  const mockEndpoint = (0, import_nock.default)(mockResponse.url).post("").reply(reply.status, reply.body);
+var mockEndpointUpsertUserStorage = (mockReply) => {
+  const mockResponse = getMockUserStoragePutResponse();
+  const mockEndpoint = (0, import_nock.default)(mockResponse.url).put("").reply(mockReply?.status ?? 204);
   return mockEndpoint;
 };
 
+// src/NotificationServicesController/services/onchain-notifications.ts
+import log2 from "loglevel";
+var TRIGGER_API = "https://trigger.api.cx.metamask.io";
+var NOTIFICATION_API = "https://notification.api.cx.metamask.io";
+var TRIGGER_API_BATCH_ENDPOINT = `${TRIGGER_API}/api/v1/triggers/batch`;
+var NOTIFICATION_API_LIST_ENDPOINT = `${NOTIFICATION_API}/api/v1/notifications`;
+var NOTIFICATION_API_LIST_ENDPOINT_PAGE_QUERY = (page) => `${NOTIFICATION_API_LIST_ENDPOINT}?page=${page}&per_page=100`;
+var NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT = `${NOTIFICATION_API}/api/v1/notifications/mark-as-read`;
+async function createOnChainTriggers(userStorage, storageKey, bearerToken, triggers) {
+  const triggersToCreate = triggers.map((t) => ({
+    id: t.id,
+    token: user_storage_exports.createSHA256Hash(t.id + storageKey),
+    config: {
+      kind: t.kind,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      chain_id: Number(t.chainId),
+      address: t.address
+    }
+  }));
+  if (triggersToCreate.length === 0) {
+    return;
+  }
+  const response = await makeApiCall(
+    bearerToken,
+    TRIGGER_API_BATCH_ENDPOINT,
+    "POST",
+    triggersToCreate
+  );
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => void 0);
+    log2.error("Error creating triggers:", errorData);
+    throw new Error("OnChain Notifications - unable to create triggers");
+  }
+  for (const trigger of triggersToCreate) {
+    toggleUserStorageTriggerStatus(
+      userStorage,
+      trigger.config.address,
+      String(trigger.config.chain_id),
+      trigger.id,
+      true
+    );
+  }
+}
+async function deleteOnChainTriggers(userStorage, storageKey, bearerToken, uuids) {
+  const triggersToDelete = uuids.map((uuid) => ({
+    id: uuid,
+    token: user_storage_exports.createSHA256Hash(uuid + storageKey)
+  }));
+  try {
+    const response = await makeApiCall(
+      bearerToken,
+      TRIGGER_API_BATCH_ENDPOINT,
+      "DELETE",
+      triggersToDelete
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to delete on-chain notifications for uuids ${uuids.join(", ")}`
+      );
+    }
+    for (const uuid of uuids) {
+      for (const address in userStorage) {
+        if (address in userStorage) {
+          for (const chainId in userStorage[address]) {
+            if (userStorage?.[address]?.[chainId]?.[uuid]) {
+              delete userStorage[address][chainId][uuid];
+            }
+          }
+        }
+      }
+    }
+    const isEmpty = (obj = {}) => Object.keys(obj).length === 0;
+    for (const address in userStorage) {
+      if (address in userStorage) {
+        for (const chainId in userStorage[address]) {
+          if (isEmpty(userStorage?.[address]?.[chainId])) {
+            delete userStorage[address][chainId];
+          }
+        }
+        if (isEmpty(userStorage?.[address])) {
+          delete userStorage[address];
+        }
+      }
+    }
+  } catch (err) {
+    log2.error(
+      `Error deleting on-chain notifications for uuids ${uuids.join(", ")}:`,
+      err
+    );
+    throw err;
+  }
+  return userStorage;
+}
+async function getOnChainNotifications(userStorage, bearerToken) {
+  const triggerIds = traverseUserStorageTriggers(userStorage, {
+    mapTrigger: (t) => {
+      if (!t.enabled) {
+        return void 0;
+      }
+      return t.id;
+    }
+  });
+  if (triggerIds.length === 0) {
+    return [];
+  }
+  const onChainNotifications = [];
+  const PAGE_LIMIT = 2;
+  for (let page = 1; page <= PAGE_LIMIT; page++) {
+    try {
+      const response = await makeApiCall(
+        bearerToken,
+        NOTIFICATION_API_LIST_ENDPOINT_PAGE_QUERY(page),
+        "POST",
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        { trigger_ids: triggerIds }
+      );
+      const notifications = await response.json();
+      const transformedNotifications = notifications.map(
+        (n) => {
+          if (!n.data?.kind) {
+            return void 0;
+          }
+          return {
+            ...n,
+            type: n.data.kind
+          };
+        }
+      ).filter((n) => Boolean(n));
+      onChainNotifications.push(...transformedNotifications);
+      if (notifications.length < 100) {
+        page = PAGE_LIMIT + 1;
+        break;
+      }
+    } catch (err) {
+      log2.error(
+        `Error fetching on-chain notifications for trigger IDs ${triggerIds.join(
+          ", "
+        )}:`,
+        err
+      );
+    }
+  }
+  return onChainNotifications;
+}
+async function markNotificationsAsRead(bearerToken, notificationIds) {
+  if (notificationIds.length === 0) {
+    return;
+  }
+  try {
+    const response = await makeApiCall(
+      bearerToken,
+      NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT,
+      "POST",
+      { ids: notificationIds }
+    );
+    if (response.status !== 200) {
+      const errorData = await response.json().catch(() => void 0);
+      throw new Error(
+        `Error marking notifications as read: ${errorData?.message}`
+      );
+    }
+  } catch (err) {
+    log2.error("Error marking notifications as read:", err);
+    throw err;
+  }
+}
+
 export {
   require_nock,
-  fixtures_exports,
-  NotificationServicesController_exports
+  TRIGGER_API,
+  NOTIFICATION_API,
+  TRIGGER_API_BATCH_ENDPOINT,
+  NOTIFICATION_API_LIST_ENDPOINT,
+  NOTIFICATION_API_LIST_ENDPOINT_PAGE_QUERY,
+  NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT,
+  createOnChainTriggers,
+  deleteOnChainTriggers,
+  getOnChainNotifications,
+  markNotificationsAsRead
 };
-//# sourceMappingURL=chunk-KTQP5UDT.mjs.map
+/*! Bundled license information:
+
+@noble/ciphers/esm/utils.js:
+  (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=chunk-IG3CMJBW.mjs.map