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

package/dist/{chunk-KKWCKF5W.mjs → chunk-4QS664EH.mjs}

@@ -9,7 +9,7 @@ import {
   deleteOnChainTriggers,
   getOnChainNotifications,
   markNotificationsAsRead
-} from "./chunk-F6TSWKZK.mjs";
+} from "./chunk-IG3CMJBW.mjs";
 import {
   checkAccountsPresence,
   getAllUUIDs,
@@ -799,4 +799,4 @@ export {
   defaultState,
   NotificationServicesController
 };
-//# sourceMappingURL=chunk-KKWCKF5W.mjs.map
+//# sourceMappingURL=chunk-4QS664EH.mjs.map

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

@@ -7,6 +7,7 @@ import {
   __commonJS,
   __export,
   __privateAdd,
+  __privateGet,
   __privateMethod,
   __require,
   __toESM
@@ -4702,13 +4703,48 @@ var SHA256 = class extends HashMD {
 };
 var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
+// ../../node_modules/@metamask/snaps-utils/dist/chunk-5R7UF7KM.mjs
+var HandlerType = /* @__PURE__ */ ((HandlerType2) => {
+  HandlerType2["OnRpcRequest"] = "onRpcRequest";
+  HandlerType2["OnSignature"] = "onSignature";
+  HandlerType2["OnTransaction"] = "onTransaction";
+  HandlerType2["OnCronjob"] = "onCronjob";
+  HandlerType2["OnInstall"] = "onInstall";
+  HandlerType2["OnUpdate"] = "onUpdate";
+  HandlerType2["OnNameLookup"] = "onNameLookup";
+  HandlerType2["OnKeyringRequest"] = "onKeyringRequest";
+  HandlerType2["OnHomePage"] = "onHomePage";
+  HandlerType2["OnUserInput"] = "onUserInput";
+  return HandlerType2;
+})(HandlerType || {});
+var SNAP_EXPORT_NAMES = Object.values(HandlerType);
+
+// ../profile-sync-controller/src/controllers/authentication/auth-snap-requests.ts
+var snapId = "npm:@metamask/message-signing-snap";
+function createSnapSignMessageRequest(message) {
+  return {
+    snapId,
+    origin: "",
+    handler: HandlerType.OnRpcRequest,
+    request: {
+      method: "signMessage",
+      params: { message }
+    }
+  };
+}
+
 // ../profile-sync-controller/src/controllers/user-storage/index.ts
 var user_storage_exports = {};
 __export(user_storage_exports, {
+  Controller: () => UserStorageController,
+  Encryption: () => encryption_default,
   Mocks: () => fixtures_exports,
   createSHA256Hash: () => createSHA256Hash
 });
 
+// ../profile-sync-controller/src/controllers/user-storage/UserStorageController.ts
+import { BaseController } from "@metamask/base-controller";
+
 // ../../node_modules/@noble/hashes/esm/scrypt.js
 function XorAndSalsa(prev, pi, input, ii, out, oi) {
   let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
@@ -5083,6 +5119,305 @@ function createEntryPath(entryKey, storageKey) {
 var ENV_URLS2 = getEnvUrls("prd" /* PRD */);
 var USER_STORAGE_API = ENV_URLS2.userStorageApiUrl;
 var USER_STORAGE_ENDPOINT = `${USER_STORAGE_API}/api/v1/userstorage`;
+async function getUserStorage(opts) {
+  try {
+    const path = createEntryPath(opts.entryKey, opts.storageKey);
+    const url = new URL(`${USER_STORAGE_ENDPOINT}${path}`);
+    const userStorageResponse = await fetch(url.toString(), {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${opts.bearerToken}`
+      }
+    });
+    if (userStorageResponse.status === 404) {
+      return null;
+    }
+    if (userStorageResponse.status !== 200) {
+      throw new Error("Unable to get User Storage");
+    }
+    const userStorage = await userStorageResponse.json();
+    const encryptedData = userStorage?.Data ?? null;
+    if (!encryptedData) {
+      return null;
+    }
+    const decryptedData = encryption_default2.decryptString(
+      encryptedData,
+      opts.storageKey
+    );
+    return decryptedData;
+  } catch (e) {
+    log.error("Failed to get user storage", e);
+    return null;
+  }
+}
+async function upsertUserStorage(data, opts) {
+  const encryptedData = encryption_default2.encryptString(data, opts.storageKey);
+  const path = createEntryPath(opts.entryKey, opts.storageKey);
+  const url = new URL(`${USER_STORAGE_ENDPOINT}${path}`);
+  const res = await fetch(url.toString(), {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${opts.bearerToken}`
+    },
+    body: JSON.stringify({ data: encryptedData })
+  });
+  if (!res.ok) {
+    throw new Error("user-storage - unable to upsert data");
+  }
+}
+
+// ../profile-sync-controller/src/controllers/user-storage/UserStorageController.ts
+var controllerName = "UserStorageController";
+var defaultState = {
+  isProfileSyncingEnabled: true,
+  isProfileSyncingUpdateLoading: false
+};
+var metadata = {
+  isProfileSyncingEnabled: {
+    persist: true,
+    anonymous: true
+  },
+  isProfileSyncingUpdateLoading: {
+    persist: false,
+    anonymous: false
+  }
+};
+var _auth, _notificationServices, _registerMessageHandlers, registerMessageHandlers_fn, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn, _createStorageKey, createStorageKey_fn, _snapSignMessage, snapSignMessage_fn, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn;
+var UserStorageController = class extends BaseController {
+  constructor(params) {
+    super({
+      messenger: params.messenger,
+      metadata,
+      name: controllerName,
+      state: { ...defaultState, ...params.state }
+    });
+    /**
+     * Constructor helper for registering this controller's messaging system
+     * actions.
+     */
+    __privateAdd(this, _registerMessageHandlers);
+    __privateAdd(this, _assertProfileSyncingEnabled);
+    /**
+     * Utility to get the bearer token and storage key
+     */
+    __privateAdd(this, _getStorageKeyAndBearerToken);
+    /**
+     * Rather than storing the storage key, we can compute the storage key when needed.
+     *
+     * @returns the storage key
+     */
+    __privateAdd(this, _createStorageKey);
+    /**
+     * Signs a specific message using an underlying auth snap.
+     *
+     * @param message - A specific tagged message to sign.
+     * @returns A Signature created by the snap.
+     */
+    __privateAdd(this, _snapSignMessage);
+    __privateAdd(this, _setIsProfileSyncingUpdateLoading);
+    __privateAdd(this, _auth, {
+      getBearerToken: async () => {
+        return await this.messagingSystem.call(
+          "AuthenticationController:getBearerToken"
+        );
+      },
+      getProfileId: async () => {
+        const sessionProfile = await this.messagingSystem.call(
+          "AuthenticationController:getSessionProfile"
+        );
+        return sessionProfile?.profileId;
+      },
+      isAuthEnabled: () => {
+        return this.messagingSystem.call("AuthenticationController:isSignedIn");
+      },
+      signIn: async () => {
+        return await this.messagingSystem.call(
+          "AuthenticationController:performSignIn"
+        );
+      },
+      signOut: async () => {
+        return this.messagingSystem.call(
+          "AuthenticationController:performSignOut"
+        );
+      }
+    });
+    __privateAdd(this, _notificationServices, {
+      disableNotificationServices: async () => {
+        return await this.messagingSystem.call(
+          "NotificationServicesController:disableNotificationServices"
+        );
+      },
+      selectIsNotificationServicesEnabled: async () => {
+        return this.messagingSystem.call(
+          "NotificationServicesController:selectIsNotificationServicesEnabled"
+        );
+      }
+    });
+    this.getMetaMetricsState = params.getMetaMetricsState;
+    __privateMethod(this, _registerMessageHandlers, registerMessageHandlers_fn).call(this);
+  }
+  async enableProfileSyncing() {
+    try {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, true);
+      const authEnabled = __privateGet(this, _auth).isAuthEnabled();
+      if (!authEnabled) {
+        await __privateGet(this, _auth).signIn();
+      }
+      this.update((state) => {
+        state.isProfileSyncingEnabled = true;
+      });
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+    } catch (e) {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(
+        `${controllerName} - failed to enable profile syncing - ${errorMessage}`
+      );
+    }
+  }
+  async setIsProfileSyncingEnabled(isProfileSyncingEnabled) {
+    this.update((state) => {
+      state.isProfileSyncingEnabled = isProfileSyncingEnabled;
+    });
+  }
+  async disableProfileSyncing() {
+    const isAlreadyDisabled = !this.state.isProfileSyncingEnabled;
+    if (isAlreadyDisabled) {
+      return;
+    }
+    try {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, true);
+      const isNotificationServicesEnabled = await __privateGet(this, _notificationServices).selectIsNotificationServicesEnabled();
+      if (isNotificationServicesEnabled) {
+        await __privateGet(this, _notificationServices).disableNotificationServices();
+      }
+      const isMetaMetricsParticipation = this.getMetaMetricsState();
+      if (!isMetaMetricsParticipation) {
+        this.messagingSystem.call("AuthenticationController:performSignOut");
+      }
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      this.update((state) => {
+        state.isProfileSyncingEnabled = false;
+      });
+    } catch (e) {
+      __privateMethod(this, _setIsProfileSyncingUpdateLoading, setIsProfileSyncingUpdateLoading_fn).call(this, false);
+      const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+      throw new Error(
+        `${controllerName} - failed to disable profile syncing - ${errorMessage}`
+      );
+    }
+  }
+  /**
+   * Allows retrieval of stored data. Data stored is string formatted.
+   * Developers can extend the entry path and entry name through the `schema.ts` file.
+   *
+   * @param entryKey - entry key that matches schema
+   * @returns the decrypted string contents found from user storage (or null if not found)
+   */
+  async performGetStorage(entryKey) {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const { bearerToken, storageKey } = await __privateMethod(this, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn).call(this);
+    const result = await getUserStorage({
+      entryKey,
+      bearerToken,
+      storageKey
+    });
+    return result;
+  }
+  /**
+   * Allows storage of user data. Data stored must be string formatted.
+   * Developers can extend the entry path and entry name through the `schema.ts` file.
+   *
+   * @param entryKey - entry key that matches schema
+   * @param value - The string data you want to store.
+   * @returns nothing. NOTE that an error is thrown if fails to store data.
+   */
+  async performSetStorage(entryKey, value) {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const { bearerToken, storageKey } = await __privateMethod(this, _getStorageKeyAndBearerToken, getStorageKeyAndBearerToken_fn).call(this);
+    await upsertUserStorage(value, {
+      entryKey,
+      bearerToken,
+      storageKey
+    });
+  }
+  /**
+   * Retrieves the storage key, for internal use only!
+   *
+   * @returns the storage key
+   */
+  async getStorageKey() {
+    __privateMethod(this, _assertProfileSyncingEnabled, assertProfileSyncingEnabled_fn).call(this);
+    const storageKey = await __privateMethod(this, _createStorageKey, createStorageKey_fn).call(this);
+    return storageKey;
+  }
+};
+_auth = new WeakMap();
+_notificationServices = new WeakMap();
+_registerMessageHandlers = new WeakSet();
+registerMessageHandlers_fn = function() {
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:performGetStorage",
+    this.performGetStorage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:performSetStorage",
+    this.performSetStorage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:getStorageKey",
+    this.getStorageKey.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:enableProfileSyncing",
+    this.enableProfileSyncing.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    "UserStorageController:disableProfileSyncing",
+    this.disableProfileSyncing.bind(this)
+  );
+};
+_assertProfileSyncingEnabled = new WeakSet();
+assertProfileSyncingEnabled_fn = function() {
+  if (!this.state.isProfileSyncingEnabled) {
+    throw new Error(
+      `${controllerName}: Unable to call method, user is not authenticated`
+    );
+  }
+};
+_getStorageKeyAndBearerToken = new WeakSet();
+getStorageKeyAndBearerToken_fn = async function() {
+  const bearerToken = await __privateGet(this, _auth).getBearerToken();
+  if (!bearerToken) {
+    throw new Error("UserStorageController - unable to get bearer token");
+  }
+  const storageKey = await __privateMethod(this, _createStorageKey, createStorageKey_fn).call(this);
+  return { bearerToken, storageKey };
+};
+_createStorageKey = new WeakSet();
+createStorageKey_fn = async function() {
+  const id = await __privateGet(this, _auth).getProfileId();
+  if (!id) {
+    throw new Error("UserStorageController - unable to create storage key");
+  }
+  const storageKeySignature = await __privateMethod(this, _snapSignMessage, snapSignMessage_fn).call(this, `metamask:${id}`);
+  const storageKey = createSHA256Hash(storageKeySignature);
+  return storageKey;
+};
+_snapSignMessage = new WeakSet();
+snapSignMessage_fn = function(message) {
+  return this.messagingSystem.call(
+    "SnapController:handleRequest",
+    createSnapSignMessageRequest(message)
+  );
+};
+_setIsProfileSyncingUpdateLoading = new WeakSet();
+setIsProfileSyncingUpdateLoading_fn = function(isProfileSyncingUpdateLoading) {
+  this.update((state) => {
+    state.isProfileSyncingUpdateLoading = isProfileSyncingUpdateLoading;
+  });
+};
 
 // ../profile-sync-controller/src/controllers/user-storage/__fixtures__/index.ts
 var fixtures_exports = {};
@@ -5336,4 +5671,4 @@ export {
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-F6TSWKZK.mjs.map
+//# sourceMappingURL=chunk-IG3CMJBW.mjs.map