@metamask-previews/profile-sync-controller 29.0.0-preview-3866c0ff1 → 29.0.0-preview-e3275932a

package/dist/controllers/user-storage/UserStorageController-method-action-types.d.mts

@@ -0,0 +1,137 @@
+/**
+ * This file is auto generated.
+ * Do not edit manually.
+ */
+import type { UserStorageController } from "./UserStorageController.mjs";
+/**
+ * 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 path - string in the form of `${feature}.${key}` that matches schema
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns the decrypted string contents found from user storage (or null if not found)
+ */
+export type UserStorageControllerPerformGetStorageAction = {
+    type: `UserStorageController:performGetStorage`;
+    handler: UserStorageController['performGetStorage'];
+};
+/**
+ * Allows retrieval of all stored data for a specific feature. Data stored is formatted as an array of strings.
+ * Developers can extend the entry path through the `schema.ts` file.
+ *
+ * @param path - string in the form of `${feature}` that matches schema
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns the array of decrypted string contents found from user storage (or null if not found)
+ */
+export type UserStorageControllerPerformGetStorageAllFeatureEntriesAction = {
+    type: `UserStorageController:performGetStorageAllFeatureEntries`;
+    handler: UserStorageController['performGetStorageAllFeatureEntries'];
+};
+/**
+ * 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 path - string in the form of `${feature}.${key}` that matches schema
+ * @param value - The string data you want to store.
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns nothing. NOTE that an error is thrown if fails to store data.
+ */
+export type UserStorageControllerPerformSetStorageAction = {
+    type: `UserStorageController:performSetStorage`;
+    handler: UserStorageController['performSetStorage'];
+};
+/**
+ * Allows storage of multiple user data entries for one specific feature. Data stored must be string formatted.
+ * Developers can extend the entry path through the `schema.ts` file.
+ *
+ * @param path - string in the form of `${feature}` that matches schema
+ * @param values - data to store, in the form of an array of `[entryKey, entryValue]` pairs
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns nothing. NOTE that an error is thrown if fails to store data.
+ */
+export type UserStorageControllerPerformBatchSetStorageAction = {
+    type: `UserStorageController:performBatchSetStorage`;
+    handler: UserStorageController['performBatchSetStorage'];
+};
+/**
+ * Allows deletion of user data. Developers can extend the entry path and entry name through the `schema.ts` file.
+ *
+ * @param path - string in the form of `${feature}.${key}` that matches schema
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns nothing. NOTE that an error is thrown if fails to delete data.
+ */
+export type UserStorageControllerPerformDeleteStorageAction = {
+    type: `UserStorageController:performDeleteStorage`;
+    handler: UserStorageController['performDeleteStorage'];
+};
+/**
+ * Allows deletion of all user data entries for a specific feature.
+ * Developers can extend the entry path through the `schema.ts` file.
+ *
+ * @param path - string in the form of `${feature}` that matches schema
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns nothing. NOTE that an error is thrown if fails to delete data.
+ */
+export type UserStorageControllerPerformDeleteStorageAllFeatureEntriesAction = {
+    type: `UserStorageController:performDeleteStorageAllFeatureEntries`;
+    handler: UserStorageController['performDeleteStorageAllFeatureEntries'];
+};
+/**
+ * Allows delete of multiple user data entries for one specific feature. Data deleted must be string formatted.
+ * Developers can extend the entry path through the `schema.ts` file.
+ *
+ * @param path - string in the form of `${feature}` that matches schema
+ * @param values - data to store, in the form of an array of entryKey[]
+ * @param entropySourceId - The entropy source ID used to generate the encryption key.
+ * @returns nothing. NOTE that an error is thrown if fails to store data.
+ */
+export type UserStorageControllerPerformBatchDeleteStorageAction = {
+    type: `UserStorageController:performBatchDeleteStorage`;
+    handler: UserStorageController['performBatchDeleteStorage'];
+};
+/**
+ * Retrieves the storage key, for internal use only!
+ *
+ * @returns the storage key
+ */
+export type UserStorageControllerGetStorageKeyAction = {
+    type: `UserStorageController:getStorageKey`;
+    handler: UserStorageController['getStorageKey'];
+};
+/**
+ * Lists all the available HD keyring metadata IDs.
+ * These IDs can be used in a multi-SRP context to segregate data specific to different SRPs.
+ *
+ * @returns A promise that resolves to an array of HD keyring metadata IDs.
+ */
+export type UserStorageControllerListEntropySourcesAction = {
+    type: `UserStorageController:listEntropySources`;
+    handler: UserStorageController['listEntropySources'];
+};
+export type UserStorageControllerSetIsBackupAndSyncFeatureEnabledAction = {
+    type: `UserStorageController:setIsBackupAndSyncFeatureEnabled`;
+    handler: UserStorageController['setIsBackupAndSyncFeatureEnabled'];
+};
+/**
+ * Sets the isContactSyncingInProgress flag to prevent infinite loops during contact synchronization
+ *
+ * @param isContactSyncingInProgress - Whether contact syncing is in progress
+ */
+export type UserStorageControllerSetIsContactSyncingInProgressAction = {
+    type: `UserStorageController:setIsContactSyncingInProgress`;
+    handler: UserStorageController['setIsContactSyncingInProgress'];
+};
+/**
+ * Syncs the address book list with the user storage address book list.
+ * This method is used to make sure that the address book list is up-to-date with the user storage address book list and vice-versa.
+ * It will add new contacts to the address book list, update/merge conflicting contacts and re-upload the results in some cases to the user storage.
+ */
+export type UserStorageControllerSyncContactsWithUserStorageAction = {
+    type: `UserStorageController:syncContactsWithUserStorage`;
+    handler: UserStorageController['syncContactsWithUserStorage'];
+};
+/**
+ * Union of all UserStorageController action types.
+ */
+export type UserStorageControllerMethodActions = UserStorageControllerPerformGetStorageAction | UserStorageControllerPerformGetStorageAllFeatureEntriesAction | UserStorageControllerPerformSetStorageAction | UserStorageControllerPerformBatchSetStorageAction | UserStorageControllerPerformDeleteStorageAction | UserStorageControllerPerformDeleteStorageAllFeatureEntriesAction | UserStorageControllerPerformBatchDeleteStorageAction | UserStorageControllerGetStorageKeyAction | UserStorageControllerListEntropySourcesAction | UserStorageControllerSetIsBackupAndSyncFeatureEnabledAction | UserStorageControllerSetIsContactSyncingInProgressAction | UserStorageControllerSyncContactsWithUserStorageAction;
+//# sourceMappingURL=UserStorageController-method-action-types.d.mts.map

package/dist/controllers/user-storage/UserStorageController-method-action-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserStorageController-method-action-types.d.mts","sourceRoot":"","sources":["../../../src/controllers/user-storage/UserStorageController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,oCAAmC;AAExE;;;;;;;GAOG;AACH,MAAM,MAAM,4CAA4C,GAAG;IACzD,IAAI,EAAE,yCAAyC,CAAC;IAChD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,CAAC;CACrD,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,6DAA6D,GAAG;IAC1E,IAAI,EAAE,0DAA0D,CAAC;IACjE,OAAO,EAAE,qBAAqB,CAAC,oCAAoC,CAAC,CAAC;CACtE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,4CAA4C,GAAG;IACzD,IAAI,EAAE,yCAAyC,CAAC;IAChD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,CAAC;CACrD,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,iDAAiD,GAAG;IAC9D,IAAI,EAAE,8CAA8C,CAAC;IACrD,OAAO,EAAE,qBAAqB,CAAC,wBAAwB,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,+CAA+C,GAAG;IAC5D,IAAI,EAAE,4CAA4C,CAAC;IACnD,OAAO,EAAE,qBAAqB,CAAC,sBAAsB,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,gEAAgE,GAAG;IAC7E,IAAI,EAAE,6DAA6D,CAAC;IACpE,OAAO,EAAE,qBAAqB,CAAC,uCAAuC,CAAC,CAAC;CACzE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,oDAAoD,GAAG;IACjE,IAAI,EAAE,iDAAiD,CAAC;IACxD,OAAO,EAAE,qBAAqB,CAAC,2BAA2B,CAAC,CAAC;CAC7D,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,wCAAwC,GAAG;IACrD,IAAI,EAAE,qCAAqC,CAAC;IAC5C,OAAO,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,6CAA6C,GAAG;IAC1D,IAAI,EAAE,0CAA0C,CAAC;IACjD,OAAO,EAAE,qBAAqB,CAAC,oBAAoB,CAAC,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,2DAA2D,GAAG;IACxE,IAAI,EAAE,wDAAwD,CAAC;IAC/D,OAAO,EAAE,qBAAqB,CAAC,kCAAkC,CAAC,CAAC;CACpE,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,wDAAwD,GAAG;IACrE,IAAI,EAAE,qDAAqD,CAAC;IAC5D,OAAO,EAAE,qBAAqB,CAAC,+BAA+B,CAAC,CAAC;CACjE,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,sDAAsD,GAAG;IACnE,IAAI,EAAE,mDAAmD,CAAC;IAC1D,OAAO,EAAE,qBAAqB,CAAC,6BAA6B,CAAC,CAAC;CAC/D,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,kCAAkC,GAC1C,4CAA4C,GAC5C,6DAA6D,GAC7D,4CAA4C,GAC5C,iDAAiD,GACjD,+CAA+C,GAC/C,gEAAgE,GAChE,oDAAoD,GACpD,wCAAwC,GACxC,6CAA6C,GAC7C,2DAA2D,GAC3D,wDAAwD,GACxD,sDAAsD,CAAC"}

package/dist/controllers/user-storage/{UserStorageController-method-action-types.js → UserStorageController-method-action-types.mjs}

@@ -3,4 +3,4 @@
  * Do not edit manually.
  */
 export {};
-//# sourceMappingURL=UserStorageController-method-action-types.js.map
+//# sourceMappingURL=UserStorageController-method-action-types.mjs.map

package/dist/controllers/user-storage/UserStorageController-method-action-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserStorageController-method-action-types.mjs","sourceRoot":"","sources":["../../../src/controllers/user-storage/UserStorageController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { UserStorageController } from './UserStorageController.js';\n\n/**\n * Allows retrieval of stored data. Data stored is string formatted.\n * Developers can extend the entry path and entry name through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}.${key}` that matches schema\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns the decrypted string contents found from user storage (or null if not found)\n */\nexport type UserStorageControllerPerformGetStorageAction = {\n  type: `UserStorageController:performGetStorage`;\n  handler: UserStorageController['performGetStorage'];\n};\n\n/**\n * Allows retrieval of all stored data for a specific feature. Data stored is formatted as an array of strings.\n * Developers can extend the entry path through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}` that matches schema\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns the array of decrypted string contents found from user storage (or null if not found)\n */\nexport type UserStorageControllerPerformGetStorageAllFeatureEntriesAction = {\n  type: `UserStorageController:performGetStorageAllFeatureEntries`;\n  handler: UserStorageController['performGetStorageAllFeatureEntries'];\n};\n\n/**\n * Allows storage of user data. Data stored must be string formatted.\n * Developers can extend the entry path and entry name through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}.${key}` that matches schema\n * @param value - The string data you want to store.\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns nothing. NOTE that an error is thrown if fails to store data.\n */\nexport type UserStorageControllerPerformSetStorageAction = {\n  type: `UserStorageController:performSetStorage`;\n  handler: UserStorageController['performSetStorage'];\n};\n\n/**\n * Allows storage of multiple user data entries for one specific feature. Data stored must be string formatted.\n * Developers can extend the entry path through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}` that matches schema\n * @param values - data to store, in the form of an array of `[entryKey, entryValue]` pairs\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns nothing. NOTE that an error is thrown if fails to store data.\n */\nexport type UserStorageControllerPerformBatchSetStorageAction = {\n  type: `UserStorageController:performBatchSetStorage`;\n  handler: UserStorageController['performBatchSetStorage'];\n};\n\n/**\n * Allows deletion of user data. Developers can extend the entry path and entry name through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}.${key}` that matches schema\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns nothing. NOTE that an error is thrown if fails to delete data.\n */\nexport type UserStorageControllerPerformDeleteStorageAction = {\n  type: `UserStorageController:performDeleteStorage`;\n  handler: UserStorageController['performDeleteStorage'];\n};\n\n/**\n * Allows deletion of all user data entries for a specific feature.\n * Developers can extend the entry path through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}` that matches schema\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns nothing. NOTE that an error is thrown if fails to delete data.\n */\nexport type UserStorageControllerPerformDeleteStorageAllFeatureEntriesAction = {\n  type: `UserStorageController:performDeleteStorageAllFeatureEntries`;\n  handler: UserStorageController['performDeleteStorageAllFeatureEntries'];\n};\n\n/**\n * Allows delete of multiple user data entries for one specific feature. Data deleted must be string formatted.\n * Developers can extend the entry path through the `schema.ts` file.\n *\n * @param path - string in the form of `${feature}` that matches schema\n * @param values - data to store, in the form of an array of entryKey[]\n * @param entropySourceId - The entropy source ID used to generate the encryption key.\n * @returns nothing. NOTE that an error is thrown if fails to store data.\n */\nexport type UserStorageControllerPerformBatchDeleteStorageAction = {\n  type: `UserStorageController:performBatchDeleteStorage`;\n  handler: UserStorageController['performBatchDeleteStorage'];\n};\n\n/**\n * Retrieves the storage key, for internal use only!\n *\n * @returns the storage key\n */\nexport type UserStorageControllerGetStorageKeyAction = {\n  type: `UserStorageController:getStorageKey`;\n  handler: UserStorageController['getStorageKey'];\n};\n\n/**\n * Lists all the available HD keyring metadata IDs.\n * These IDs can be used in a multi-SRP context to segregate data specific to different SRPs.\n *\n * @returns A promise that resolves to an array of HD keyring metadata IDs.\n */\nexport type UserStorageControllerListEntropySourcesAction = {\n  type: `UserStorageController:listEntropySources`;\n  handler: UserStorageController['listEntropySources'];\n};\n\nexport type UserStorageControllerSetIsBackupAndSyncFeatureEnabledAction = {\n  type: `UserStorageController:setIsBackupAndSyncFeatureEnabled`;\n  handler: UserStorageController['setIsBackupAndSyncFeatureEnabled'];\n};\n\n/**\n * Sets the isContactSyncingInProgress flag to prevent infinite loops during contact synchronization\n *\n * @param isContactSyncingInProgress - Whether contact syncing is in progress\n */\nexport type UserStorageControllerSetIsContactSyncingInProgressAction = {\n  type: `UserStorageController:setIsContactSyncingInProgress`;\n  handler: UserStorageController['setIsContactSyncingInProgress'];\n};\n\n/**\n * Syncs the address book list with the user storage address book list.\n * This method is used to make sure that the address book list is up-to-date with the user storage address book list and vice-versa.\n * It will add new contacts to the address book list, update/merge conflicting contacts and re-upload the results in some cases to the user storage.\n */\nexport type UserStorageControllerSyncContactsWithUserStorageAction = {\n  type: `UserStorageController:syncContactsWithUserStorage`;\n  handler: UserStorageController['syncContactsWithUserStorage'];\n};\n\n/**\n * Union of all UserStorageController action types.\n */\nexport type UserStorageControllerMethodActions =\n  | UserStorageControllerPerformGetStorageAction\n  | UserStorageControllerPerformGetStorageAllFeatureEntriesAction\n  | UserStorageControllerPerformSetStorageAction\n  | UserStorageControllerPerformBatchSetStorageAction\n  | UserStorageControllerPerformDeleteStorageAction\n  | UserStorageControllerPerformDeleteStorageAllFeatureEntriesAction\n  | UserStorageControllerPerformBatchDeleteStorageAction\n  | UserStorageControllerGetStorageKeyAction\n  | UserStorageControllerListEntropySourcesAction\n  | UserStorageControllerSetIsBackupAndSyncFeatureEnabledAction\n  | UserStorageControllerSetIsContactSyncingInProgressAction\n  | UserStorageControllerSyncContactsWithUserStorageAction;\n"]}

package/dist/controllers/user-storage/UserStorageController.cjs

@@ -0,0 +1,412 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _UserStorageController_instances, _UserStorageController_userStorage, _UserStorageController_auth, _UserStorageController_config, _UserStorageController_trace, _UserStorageController_isUnlocked, _UserStorageController_storageKeyCache, _UserStorageController_signMessageCache, _UserStorageController_keyringController, _UserStorageController_nativeScryptCrypto, _UserStorageController_getHdKeyringEntropySourceIds, _UserStorageController_getPrimaryEntropySourceId, _UserStorageController_scopedCacheKey, _UserStorageController_signMessage, _UserStorageController_setIsBackupAndSyncUpdateLoading;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStorageController = exports.defaultState = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const index_js_1 = require("../../sdk/index.cjs");
+const entropy_source_js_1 = require("../../shared/utils/entropy-source.cjs");
+const event_queue_js_1 = require("../../shared/utils/event-queue.cjs");
+const hd_keyring_seed_js_1 = require("../../shared/utils/hd-keyring-seed.cjs");
+const message_signing_js_1 = require("../../shared/utils/message-signing.cjs");
+const constants_js_1 = require("./constants.cjs");
+const controller_integration_js_1 = require("./contact-syncing/controller-integration.cjs");
+const setup_subscriptions_js_1 = require("./contact-syncing/setup-subscriptions.cjs");
+const controllerName = 'UserStorageController';
+exports.defaultState = {
+    isBackupAndSyncEnabled: true,
+    isBackupAndSyncUpdateLoading: false,
+    isAccountSyncingEnabled: true,
+    isContactSyncingEnabled: true,
+    isContactSyncingInProgress: false,
+};
+const metadata = {
+    isBackupAndSyncEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    isBackupAndSyncUpdateLoading: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isAccountSyncingEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    isContactSyncingEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    isContactSyncingInProgress: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'performGetStorage',
+    'performGetStorageAllFeatureEntries',
+    'performSetStorage',
+    'performBatchSetStorage',
+    'performDeleteStorage',
+    'performBatchDeleteStorage',
+    'getStorageKey',
+    'performDeleteStorageAllFeatureEntries',
+    'listEntropySources',
+    'setIsBackupAndSyncFeatureEnabled',
+    'setIsContactSyncingInProgress',
+    'syncContactsWithUserStorage',
+];
+/**
+ * Reusable controller that allows any team to store synchronized data for a given user.
+ * These can be settings shared cross MetaMask clients, or data we want to persist when uninstalling/reinstalling.
+ *
+ * NOTE:
+ * - data stored on UserStorage is FULLY encrypted, with the only keys stored/managed on the client.
+ * - No one can access this data unless they are have the SRP and are able to run the signing snap.
+ */
+class UserStorageController extends base_controller_1.BaseController {
+    constructor({ messenger, state, config, nativeScryptCrypto, trace, }) {
+        super({
+            messenger,
+            metadata,
+            name: controllerName,
+            state: { ...exports.defaultState, ...state },
+        });
+        _UserStorageController_instances.add(this);
+        _UserStorageController_userStorage.set(this, void 0);
+        _UserStorageController_auth.set(this, {
+            getProfileId: async (entropySourceId) => {
+                const sessionProfile = await this.messenger.call('AuthenticationController:getSessionProfile', entropySourceId);
+                return sessionProfile?.profileId;
+            },
+            isSignedIn: () => {
+                return this.messenger.call('AuthenticationController:isSignedIn');
+            },
+            signIn: async () => {
+                return await this.messenger.call('AuthenticationController:performSignIn');
+            },
+        });
+        _UserStorageController_config.set(this, {
+            env: index_js_1.Env.PRD,
+        });
+        _UserStorageController_trace.set(this, void 0);
+        _UserStorageController_isUnlocked.set(this, false);
+        // Both caches are keyed by `${entropySourceId}:${message}` (the primary SRP
+        // resolves to its HD keyring metadata ID) so two SRPs that transiently
+        // resolve to the same `profileId` can never share a cached storage key /
+        // signature and leak data across each other's user storage.
+        _UserStorageController_storageKeyCache.set(this, {});
+        _UserStorageController_signMessageCache.set(this, {});
+        _UserStorageController_keyringController.set(this, {
+            setupLockedStateSubscriptions: () => {
+                const { isUnlocked } = this.messenger.call('KeyringController:getState');
+                __classPrivateFieldSet(this, _UserStorageController_isUnlocked, isUnlocked, "f");
+                this.messenger.subscribe('KeyringController:unlock', () => {
+                    __classPrivateFieldSet(this, _UserStorageController_isUnlocked, true, "f");
+                });
+                this.messenger.subscribe('KeyringController:lock', () => {
+                    __classPrivateFieldSet(this, _UserStorageController_isUnlocked, false, "f");
+                });
+            },
+        });
+        _UserStorageController_nativeScryptCrypto.set(this, undefined);
+        this.eventQueue = new event_queue_js_1.EventQueue();
+        __classPrivateFieldSet(this, _UserStorageController_config, {
+            ...__classPrivateFieldGet(this, _UserStorageController_config, "f"),
+            ...config,
+        }, "f");
+        __classPrivateFieldSet(this, _UserStorageController_trace, trace ??
+            (async (_request, fn) => {
+                if (!fn) {
+                    return undefined;
+                }
+                return await Promise.resolve(fn());
+            }), "f");
+        __classPrivateFieldSet(this, _UserStorageController_userStorage, new index_js_1.UserStorage({
+            env: __classPrivateFieldGet(this, _UserStorageController_config, "f").env,
+            auth: {
+                getAccessToken: (entropySourceId) => this.messenger.call('AuthenticationController:getBearerToken', entropySourceId),
+                getUserProfile: async (entropySourceId) => {
+                    return await this.messenger.call('AuthenticationController:getSessionProfile', entropySourceId);
+                },
+                signMessage: (message, entropySourceId) => __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_signMessage).call(this, message, entropySourceId),
+            },
+        }, {
+            storage: {
+                getStorageKey: async (message, entropySourceId) => {
+                    // No derived key can exist while locked (the KeyringController
+                    // clears its keyrings on lock, so the scope is unresolvable).
+                    if (!__classPrivateFieldGet(this, _UserStorageController_isUnlocked, "f")) {
+                        return null;
+                    }
+                    return (__classPrivateFieldGet(this, _UserStorageController_storageKeyCache, "f")[__classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_scopedCacheKey).call(this, message, entropySourceId)] ?? null);
+                },
+                // Only ever reached after a successful signature, i.e. while unlocked.
+                setStorageKey: async (message, key, entropySourceId) => {
+                    __classPrivateFieldGet(this, _UserStorageController_storageKeyCache, "f")[__classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_scopedCacheKey).call(this, message, entropySourceId)] = key;
+                },
+            },
+        }), "f");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        __classPrivateFieldGet(this, _UserStorageController_keyringController, "f").setupLockedStateSubscriptions();
+        __classPrivateFieldSet(this, _UserStorageController_nativeScryptCrypto, nativeScryptCrypto, "f");
+        // Contact Syncing
+        (0, setup_subscriptions_js_1.setupContactSyncingSubscriptions)({
+            getUserStorageControllerInstance: () => this,
+            getMessenger: () => this.messenger,
+            trace: __classPrivateFieldGet(this, _UserStorageController_trace, "f"),
+        });
+    }
+    /**
+     * 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 path - string in the form of `${feature}.${key}` that matches schema
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns the decrypted string contents found from user storage (or null if not found)
+     */
+    async performGetStorage(path, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").getItem(path, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Allows retrieval of all stored data for a specific feature. Data stored is formatted as an array of strings.
+     * Developers can extend the entry path through the `schema.ts` file.
+     *
+     * @param path - string in the form of `${feature}` that matches schema
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns the array of decrypted string contents found from user storage (or null if not found)
+     */
+    async performGetStorageAllFeatureEntries(path, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").getAllFeatureItems(path, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * 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 path - string in the form of `${feature}.${key}` that matches schema
+     * @param value - The string data you want to store.
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns nothing. NOTE that an error is thrown if fails to store data.
+     */
+    async performSetStorage(path, value, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").setItem(path, value, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Allows storage of multiple user data entries for one specific feature. Data stored must be string formatted.
+     * Developers can extend the entry path through the `schema.ts` file.
+     *
+     * @param path - string in the form of `${feature}` that matches schema
+     * @param values - data to store, in the form of an array of `[entryKey, entryValue]` pairs
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns nothing. NOTE that an error is thrown if fails to store data.
+     */
+    async performBatchSetStorage(path, values, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").batchSetItems(path, values, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Allows deletion of user data. Developers can extend the entry path and entry name through the `schema.ts` file.
+     *
+     * @param path - string in the form of `${feature}.${key}` that matches schema
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns nothing. NOTE that an error is thrown if fails to delete data.
+     */
+    async performDeleteStorage(path, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").deleteItem(path, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Allows deletion of all user data entries for a specific feature.
+     * Developers can extend the entry path through the `schema.ts` file.
+     *
+     * @param path - string in the form of `${feature}` that matches schema
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns nothing. NOTE that an error is thrown if fails to delete data.
+     */
+    async performDeleteStorageAllFeatureEntries(path, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").deleteAllFeatureItems(path, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Allows delete of multiple user data entries for one specific feature. Data deleted must be string formatted.
+     * Developers can extend the entry path through the `schema.ts` file.
+     *
+     * @param path - string in the form of `${feature}` that matches schema
+     * @param values - data to store, in the form of an array of entryKey[]
+     * @param entropySourceId - The entropy source ID used to generate the encryption key.
+     * @returns nothing. NOTE that an error is thrown if fails to store data.
+     */
+    async performBatchDeleteStorage(path, values, entropySourceId) {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").batchDeleteItems(path, values, {
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+            entropySourceId,
+        });
+    }
+    /**
+     * Retrieves the storage key, for internal use only!
+     *
+     * @returns the storage key
+     */
+    async getStorageKey() {
+        return await __classPrivateFieldGet(this, _UserStorageController_userStorage, "f").getStorageKey();
+    }
+    /**
+     * Flushes the storage key cache.
+     * CAUTION: This is only public for testing purposes.
+     * It should not be used in production code.
+     */
+    flushStorageKeyCache() {
+        __classPrivateFieldSet(this, _UserStorageController_storageKeyCache, {}, "f");
+    }
+    /**
+     * Lists all the available HD keyring metadata IDs.
+     * These IDs can be used in a multi-SRP context to segregate data specific to different SRPs.
+     *
+     * @returns A promise that resolves to an array of HD keyring metadata IDs.
+     */
+    async listEntropySources() {
+        if (!__classPrivateFieldGet(this, _UserStorageController_isUnlocked, "f")) {
+            throw new Error('listEntropySources - unable to list entropy sources, wallet is locked');
+        }
+        return __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getHdKeyringEntropySourceIds).call(this);
+    }
+    async setIsBackupAndSyncFeatureEnabled(feature, enabled) {
+        try {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsBackupAndSyncUpdateLoading).call(this, true);
+            if (enabled) {
+                // If any of the features are enabled, we need to ensure the user is signed in
+                const isSignedIn = __classPrivateFieldGet(this, _UserStorageController_auth, "f").isSignedIn();
+                if (!isSignedIn) {
+                    await __classPrivateFieldGet(this, _UserStorageController_auth, "f").signIn();
+                }
+            }
+            this.update((state) => {
+                if (feature === constants_js_1.BACKUPANDSYNC_FEATURES.main) {
+                    state.isBackupAndSyncEnabled = enabled;
+                }
+                if (feature === constants_js_1.BACKUPANDSYNC_FEATURES.accountSyncing) {
+                    state.isAccountSyncingEnabled = enabled;
+                }
+                if (feature === constants_js_1.BACKUPANDSYNC_FEATURES.contactSyncing) {
+                    state.isContactSyncingEnabled = enabled;
+                }
+            });
+        }
+        catch (e) {
+            // istanbul ignore next
+            const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+            // istanbul ignore next
+            throw new Error(`${controllerName} - failed to ${enabled ? 'enable' : 'disable'} ${feature} - ${errorMessage}`);
+        }
+        finally {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsBackupAndSyncUpdateLoading).call(this, false);
+        }
+    }
+    /**
+     * Sets the isContactSyncingInProgress flag to prevent infinite loops during contact synchronization
+     *
+     * @param isContactSyncingInProgress - Whether contact syncing is in progress
+     */
+    async setIsContactSyncingInProgress(isContactSyncingInProgress) {
+        this.update((state) => {
+            state.isContactSyncingInProgress = isContactSyncingInProgress;
+        });
+    }
+    /**
+     * Syncs the address book list with the user storage address book list.
+     * This method is used to make sure that the address book list is up-to-date with the user storage address book list and vice-versa.
+     * It will add new contacts to the address book list, update/merge conflicting contacts and re-upload the results in some cases to the user storage.
+     */
+    async syncContactsWithUserStorage() {
+        const profileId = await __classPrivateFieldGet(this, _UserStorageController_auth, "f").getProfileId();
+        const config = {
+            onContactUpdated: () => {
+                __classPrivateFieldGet(this, _UserStorageController_config, "f")?.contactSyncing?.onContactUpdated?.(profileId);
+            },
+            onContactDeleted: () => {
+                __classPrivateFieldGet(this, _UserStorageController_config, "f")?.contactSyncing?.onContactDeleted?.(profileId);
+            },
+            onContactSyncErroneousSituation: (errorMessage, sentryContext) => {
+                __classPrivateFieldGet(this, _UserStorageController_config, "f")?.contactSyncing?.onContactSyncErroneousSituation?.(profileId, errorMessage, sentryContext);
+            },
+        };
+        await (0, controller_integration_js_1.syncContactsWithUserStorage)(config, {
+            getMessenger: () => this.messenger,
+            getUserStorageControllerInstance: () => this,
+            trace: __classPrivateFieldGet(this, _UserStorageController_trace, "f"),
+        });
+    }
+}
+exports.UserStorageController = UserStorageController;
+_UserStorageController_userStorage = new WeakMap(), _UserStorageController_auth = new WeakMap(), _UserStorageController_config = new WeakMap(), _UserStorageController_trace = new WeakMap(), _UserStorageController_isUnlocked = new WeakMap(), _UserStorageController_storageKeyCache = new WeakMap(), _UserStorageController_signMessageCache = new WeakMap(), _UserStorageController_keyringController = new WeakMap(), _UserStorageController_nativeScryptCrypto = new WeakMap(), _UserStorageController_instances = new WeakSet(), _UserStorageController_getHdKeyringEntropySourceIds = function _UserStorageController_getHdKeyringEntropySourceIds() {
+    const { keyrings } = this.messenger.call('KeyringController:getState');
+    return (0, entropy_source_js_1.getHdKeyringEntropySourceIds)(keyrings);
+}, _UserStorageController_getPrimaryEntropySourceId = function _UserStorageController_getPrimaryEntropySourceId() {
+    const { keyrings } = this.messenger.call('KeyringController:getState');
+    return (0, entropy_source_js_1.getPrimaryHdKeyringEntropySourceId)(keyrings);
+}, _UserStorageController_scopedCacheKey = function _UserStorageController_scopedCacheKey(message, entropySourceId) {
+    return `${entropySourceId ?? __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getPrimaryEntropySourceId).call(this)}:${message}`;
+}, _UserStorageController_signMessage = 
+/**
+ * Signs a `metamask:…` message with the native SIP-6 message-signing key
+ * (same key as `@metamask/message-signing-snap` with empty salt).
+ *
+ * @param message - A specific tagged message to sign.
+ * @param entropySourceId - The entropy source ID used to derive the key,
+ * when multiple sources are available (Multi-SRP).
+ * @returns Compact secp256k1 signature hex.
+ */
+async function _UserStorageController_signMessage(message, entropySourceId) {
+    if (!__classPrivateFieldGet(this, _UserStorageController_isUnlocked, "f")) {
+        throw new Error('#signMessage - unable to proceed, wallet is locked');
+    }
+    const cacheKey = __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_scopedCacheKey).call(this, message, entropySourceId);
+    if (__classPrivateFieldGet(this, _UserStorageController_signMessageCache, "f")[cacheKey]) {
+        return __classPrivateFieldGet(this, _UserStorageController_signMessageCache, "f")[cacheKey];
+    }
+    const resolvedId = entropySourceId ?? __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getPrimaryEntropySourceId).call(this);
+    const seed = await (0, hd_keyring_seed_js_1.getHdKeyringSeed)(this.messenger, resolvedId);
+    const result = await (0, message_signing_js_1.signMessageWithMessageSigningKey)(message, seed);
+    __classPrivateFieldGet(this, _UserStorageController_signMessageCache, "f")[cacheKey] = result;
+    return result;
+}, _UserStorageController_setIsBackupAndSyncUpdateLoading = function _UserStorageController_setIsBackupAndSyncUpdateLoading(isBackupAndSyncUpdateLoading) {
+    this.update((state) => {
+        state.isBackupAndSyncUpdateLoading = isBackupAndSyncUpdateLoading;
+    });
+};
+//# sourceMappingURL=UserStorageController.cjs.map