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

package/dist/{chunk-DNTK4U5M.js → chunk-53Y2GNFU.js}

@@ -1,30 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _chunkUPVIT75Fjs = require('./chunk-UPVIT75F.js');
-
-
-var _chunk232HZSEVjs = require('./chunk-232HZSEV.js');
-
-
-
-var _chunkXNBTOK6Gjs = require('./chunk-XNBTOK6G.js');
-
-
-var _chunkZMNXLHACjs = require('./chunk-ZMNXLHAC.js');
-
-
-
-
-var _chunkVOZ7Y2OOjs = require('./chunk-VOZ7Y2OO.js');
 
 
 var _chunkPIZCE3JDjs = require('./chunk-PIZCE3JD.js');
 
 
-var _chunkCQ6CGSKZjs = require('./chunk-CQ6CGSKZ.js');
-
-
-var _chunkTLX5QQK5js = require('./chunk-TLX5QQK5.js');
 
 
 
@@ -169,12 +149,12 @@ var require_common = _chunkV46WVGWNjs.__commonJS.call(void 0, {
       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 +558,15 @@ var require_common2 = _chunkV46WVGWNjs.__commonJS.call(void 0, {
     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 +1671,7 @@ var require_interceptor = _chunkV46WVGWNjs.__commonJS.call(void 0, {
     "use strict";
     var stringify = require_stringify();
     var querystring = _chunkV46WVGWNjs.__require.call(void 0, "querystring");
-    var { URL, URLSearchParams } = _chunkV46WVGWNjs.__require.call(void 0, "url");
+    var { URL: URL2, URLSearchParams } = _chunkV46WVGWNjs.__require.call(void 0, "url");
     var common = require_common2();
     var { remove } = require_intercept();
     var matchBody = require_match_body();
@@ -1745,7 +1725,7 @@ var require_interceptor = _chunkV46WVGWNjs.__commonJS.call(void 0, {
         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 +2722,18 @@ var require_scope = _chunkV46WVGWNjs.__commonJS.call(void 0, {
     var debug = require_browser()("nock.scope");
     var { EventEmitter } = _chunkV46WVGWNjs.__require.call(void 0, "events");
     var Interceptor = require_interceptor();
-    var { URL, Url: LegacyUrl } = url;
+    var { URL: URL2, Url: LegacyUrl } = url;
     var fs;
     try {
       fs = _chunkV46WVGWNjs.__require.call(void 0, "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 +3279,13 @@ var require_back = _chunkV46WVGWNjs.__commonJS.call(void 0, {
       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 +3345,1995 @@ var require_nock = _chunkV46WVGWNjs.__commonJS.call(void 0, {
   }
 });
 
-// src/NotificationServicesController/index.ts
-var NotificationServicesController_exports = {};
-_chunkV46WVGWNjs.__export.call(void 0, NotificationServicesController_exports, {
-  Constants: () => _chunkCQ6CGSKZjs.constants_exports,
-  Mocks: () => fixtures_exports,
-  NotificationServicesController: () => _chunkXNBTOK6Gjs.NotificationServicesController,
-  Processors: () => _chunkUPVIT75Fjs.processors_exports,
-  Types: () => _chunk232HZSEVjs.types_exports,
-  defaultState: () => _chunkXNBTOK6Gjs.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 = {};
-_chunkV46WVGWNjs.__export.call(void 0, 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}`);
+  }
+}
+
+// ../../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);
+}
 
-// src/NotificationServicesController/__fixtures__/mock-feature-announcements.ts
-function createMockFeatureAnnouncementAPIResult() {
+// ../../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
-var _uuid = require('uuid');
-function createMockNotificationTrigger(override) {
-  return {
-    id: _uuid.v4.call(void 0, ),
-    address: "0xFAKE_ADDRESS",
-    chainId: "1",
-    kind: "eth_sent",
-    enabled: true,
-    ...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);
 }
-
-// src/NotificationServicesController/__fixtures__/mock-notification-user-storage.ts
-var MOCK_USER_STORAGE_ACCOUNT = "0x0000000000000000000000000000000000000000";
-var MOCK_USER_STORAGE_CHAIN = "1";
-function createMockUserStorage(override) {
-  return {
-    [_chunkTLX5QQK5js.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
-        }
-      }
-    },
-    ...override
-  };
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul22(a);
+  }
+  return res;
 }
-function createMockUserStorageWithTriggers(triggers) {
-  const userStorage = {
-    [_chunkTLX5QQK5js.USER_STORAGE_VERSION_KEY]: "1",
-    [MOCK_USER_STORAGE_ACCOUNT]: {
-      [MOCK_USER_STORAGE_CHAIN]: {}
-    }
-  };
-  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 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];
     }
-    userStorage[MOCK_USER_STORAGE_ACCOUNT][MOCK_USER_STORAGE_CHAIN][tId] = {
-      k,
-      e
-    };
-  });
-  return userStorage;
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
 }
-function createMockFullUserStorage(props = {}) {
-  return _chunkPIZCE3JDjs.initializeUserStorage.call(void 0, 
-    [{ address: props.address ?? MOCK_USER_STORAGE_ACCOUNT }],
-    props.triggersEnabled ?? true
-  );
+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;
 }
-
-// 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"
-      }
+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 {
+    encrypt: (plaintext, dst) => processCtr(plaintext, dst),
+    decrypt: (ciphertext, dst) => processCtr(ciphertext, dst)
   };
-  return mockNotification;
+});
+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}`);
+  }
 }
-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"
-      }
+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 {
+    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;
+    },
+    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);
     }
   };
-  return mockNotification;
-}
-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"
-      },
-      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"
-      }
+});
+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);
     }
   };
-  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 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++];
+    }
+    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 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"
-      }
+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;
     },
-    id: "a4193058-9814-537e-9df4-79dcac727fb6",
-    trigger_id: "028485be-b994-422b-a93b-03fcc01ab715",
-    tx_hash: "0x0833c69fb41cf972a0f031fceca242939bc3fcf82b964b74606649abcad371bd",
-    unread: true
+    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;
+    }
   };
-  return mockNotification;
-}
-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"
+});
+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;
     },
-    id: "00a79d24-befa-57ed-a55a-9eb8696e1654",
-    trigger_id: "d24ac26a-8579-49ec-9947-d04d63592ebd",
-    tx_hash: "0xe554c9e29e6eeca8ba94da4d047334ba08b8eb9ca3b801dd69cec08dfdd4ae43",
-    unread: true
+    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 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
-  };
-  return mockNotification;
+function getWebcryptoSubtle() {
+  if (cr && typeof cr.subtle === "object" && cr.subtle != null)
+    return cr.subtle;
+  throw new Error("crypto.subtle must be defined");
 }
-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"
-        }
-      },
-      from: "0x0000000000000000000000000000000000000000",
-      kind: "erc1155_received",
-      network_fee: {
-        gas_price: "33571446596",
-        native_token_price_in_usd: "2038.88"
-      }
-    },
-    id: "b6b93c84-e8dc-54ed-9396-7ea50474843a",
-    trigger_id: "710c8abb-43a9-42a5-9d86-9dd258726c82",
-    tx_hash: "0x03381aba290facbaf71c123e263c8dc3dd550aac00ef589cce395182eaeff76f",
-    unread: true
-  };
-  return mockNotification;
+
+// ../../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 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"
+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);
       },
-      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"
+      decrypt(ciphertext) {
+        bytes(ciphertext);
+        return utils.decrypt(key, keyParams, cryptParams, ciphertext);
       }
-    },
-    id: "7ddfe6a1-ac52-5ffe-aa40-f04242db4b8b",
-    trigger_id: "d2eaa2eb-2e6e-4fd5-8763-b70ea571b46c",
-    tx_hash: "0xf69074290f3aa11bce567aabc9ca0df7a12559dfae1b80ba1a124e9dfe19ecc5",
-    unread: true
+    };
   };
-  return mockNotification;
 }
-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;
+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 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"
-      }
-    },
-    id: "d8c246e7-a0a4-5f1d-b079-2b1707665fbc",
-    trigger_id: "291ec897-f569-4837-b6c0-21001b198dff",
-    tx_hash: "0xc7972a7e409abfc62590ec90e633acd70b9b74e76ad02305be8bf133a0e22d5f",
-    unread: true
-  };
-  return mockNotification;
+function isBytes2(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
 }
-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"
-      },
-      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"
-      },
-      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 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 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"
-      },
-      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"
-      },
-      network_fee: {
-        gas_price: "11658906980",
-        native_token_price_in_usd: "1576.73"
-      }
-    },
-    id: "29ddc718-78c6-5f91-936f-2bef13a605f0",
-    trigger_id: "ef003925-3379-4ba7-9e2d-8218690cadc8",
-    tx_hash: "0x58b5f82e084cb750ea174e02b20fbdfd2ba8d78053deac787f34fc38e5d427aa",
-    unread: true
-  };
-  return mockNotification;
+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 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"
-      },
-      network_fee: {
-        gas_price: "12699495150",
-        native_token_price_in_usd: "1571.74"
-      }
-    },
-    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
-    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
-    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
-    unread: true
-  };
-  return mockNotification;
+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);
 }
-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"
+
+// ../../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;
       }
-    },
-    id: "f4ef0b7f-5612-537f-9144-0b5c63ae5391",
-    trigger_id: "d73df14d-ce73-4f38-bad3-ab028154042c",
-    tx_hash: "0xe6d210d2e601ef3dd1075c48e71452cf35f2daae3886911e964e3babad8ac657",
-    unread: true
+    }
+    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());
+
+// ../profile-sync-controller/src/controllers/user-storage/index.ts
+var user_storage_exports = {};
+_chunkV46WVGWNjs.__export.call(void 0, user_storage_exports, {
+  Mocks: () => fixtures_exports,
+  createSHA256Hash: () => createSHA256Hash
+});
+
+// ../../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 createMockRawOnChainNotifications() {
-  return [1, 2, 3].map((id) => {
-    const notification = createMockNotificationEthSent();
-    notification.id += `-${id}`;
-    return notification;
-  });
+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);
+};
 
-// src/NotificationServicesController/__fixtures__/mockResponses.ts
-var CONTENTFUL_RESPONSE = createMockFeatureAnnouncementAPIResult();
-var getMockFeatureAnnouncementResponse = () => {
+// ../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 {
-    url: _chunkZMNXLHACjs.FEATURE_ANNOUNCEMENT_API,
-    requestMethod: "GET",
-    response: CONTENTFUL_RESPONSE
+    salt,
+    base64Salt,
+    key: cachedKey
   };
-};
-var getMockBatchCreateTriggersResponse = () => {
+}
+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 {
-    url: _chunkVOZ7Y2OOjs.TRIGGER_API_BATCH_ENDPOINT,
-    requestMethod: "POST",
-    response: null
+    salt: bytesSalt,
+    base64Salt,
+    key: cachedEntry[1]
+  };
+}
+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() {
+    _chunkV46WVGWNjs.__privateAdd.call(void 0, this, _encryptStringV1);
+    _chunkV46WVGWNjs.__privateAdd.call(void 0, this, _decryptStringV1);
+    _chunkV46WVGWNjs.__privateAdd.call(void 0, this, _encrypt);
+    _chunkV46WVGWNjs.__privateAdd.call(void 0, this, _decrypt);
+    _chunkV46WVGWNjs.__privateAdd.call(void 0, this, _getOrGenerateScryptKey);
+  }
+  encryptString(plaintext, password) {
+    try {
+      return _chunkV46WVGWNjs.__privateMethod.call(void 0, 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 _chunkV46WVGWNjs.__privateMethod.call(void 0, this, _decryptStringV1, decryptStringV1_fn).call(this, encryptedData, password);
+        }
+      }
+      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 } = _chunkV46WVGWNjs.__privateMethod.call(void 0, 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,
+    _chunkV46WVGWNjs.__privateMethod.call(void 0, 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
+    },
+    saltLen: SCRYPT_SALT_SIZE
   };
+  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 } = _chunkV46WVGWNjs.__privateMethod.call(void 0, this, _getOrGenerateScryptKey, getOrGenerateScryptKey_fn).call(this, password, {
+    N: o.N,
+    r: o.r,
+    p: o.p,
+    dkLen: o.dkLen
+  }, salt);
+  return bytesToUtf8(_chunkV46WVGWNjs.__privateMethod.call(void 0, 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);
 };
-var getMockBatchDeleteTriggersResponse = () => {
+_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 {
-    url: _chunkVOZ7Y2OOjs.TRIGGER_API_BATCH_ENDPOINT,
-    requestMethod: "DELETE",
-    response: null
+    key: newKey,
+    salt: newSalt
   };
 };
-var MOCK_RAW_ON_CHAIN_NOTIFICATIONS = createMockRawOnChainNotifications();
-var getMockListNotificationsResponse = () => {
+var encryption = new EncryptorDecryptor();
+var encryption_default = encryption;
+function createSHA256Hash(data) {
+  const hashedData = sha256(data);
+  return bytesToHex(hashedData);
+}
+
+// ../profile-sync-controller/src/controllers/user-storage/encryption/index.ts
+var encryption_default2 = encryption_default;
+
+// ../profile-sync-controller/src/controllers/user-storage/services.ts
+var _loglevel = require('loglevel'); var _loglevel2 = _interopRequireDefault(_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}`;
+}
+
+// ../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`;
+
+// ../profile-sync-controller/src/controllers/user-storage/__fixtures__/index.ts
+var fixtures_exports = {};
+_chunkV46WVGWNjs.__export.call(void 0, 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: _chunkVOZ7Y2OOjs.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: _chunkVOZ7Y2OOjs.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 = _chunkV46WVGWNjs.__toESM.call(void 0, 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
+
+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 _chunkPIZCE3JDjs.makeApiCall.call(void 0, 
+    bearerToken,
+    TRIGGER_API_BATCH_ENDPOINT,
+    "POST",
+    triggersToCreate
+  );
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => void 0);
+    _loglevel2.default.error("Error creating triggers:", errorData);
+    throw new Error("OnChain Notifications - unable to create triggers");
+  }
+  for (const trigger of triggersToCreate) {
+    _chunkPIZCE3JDjs.toggleUserStorageTriggerStatus.call(void 0, 
+      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 _chunkPIZCE3JDjs.makeApiCall.call(void 0, 
+      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) {
+    _loglevel2.default.error(
+      `Error deleting on-chain notifications for uuids ${uuids.join(", ")}:`,
+      err
+    );
+    throw err;
+  }
+  return userStorage;
+}
+async function getOnChainNotifications(userStorage, bearerToken) {
+  const triggerIds = _chunkPIZCE3JDjs.traverseUserStorageTriggers.call(void 0, 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 _chunkPIZCE3JDjs.makeApiCall.call(void 0, 
+        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) {
+      _loglevel2.default.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 _chunkPIZCE3JDjs.makeApiCall.call(void 0, 
+      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) {
+    _loglevel2.default.error("Error marking notifications as read:", err);
+    throw err;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
 
 
+exports.require_nock = require_nock; exports.TRIGGER_API = TRIGGER_API; exports.NOTIFICATION_API = NOTIFICATION_API; exports.TRIGGER_API_BATCH_ENDPOINT = TRIGGER_API_BATCH_ENDPOINT; exports.NOTIFICATION_API_LIST_ENDPOINT = NOTIFICATION_API_LIST_ENDPOINT; exports.NOTIFICATION_API_LIST_ENDPOINT_PAGE_QUERY = NOTIFICATION_API_LIST_ENDPOINT_PAGE_QUERY; exports.NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT = NOTIFICATION_API_MARK_ALL_AS_READ_ENDPOINT; exports.createOnChainTriggers = createOnChainTriggers; exports.deleteOnChainTriggers = deleteOnChainTriggers; exports.getOnChainNotifications = getOnChainNotifications; exports.markNotificationsAsRead = markNotificationsAsRead;
+/*! Bundled license information:
 
+@noble/ciphers/esm/utils.js:
+  (*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) *)
 
-exports.require_nock = require_nock; exports.fixtures_exports = fixtures_exports; exports.NotificationServicesController_exports = NotificationServicesController_exports;
-//# sourceMappingURL=chunk-DNTK4U5M.js.map
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=chunk-53Y2GNFU.js.map