@metamask/profile-sync-controller 0.4.0 → 0.6.0

package/dist/controllers/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStorage = exports.Authentication = void 0;
+exports.Authentication = __importStar(require("./authentication/index.cjs"));
+exports.UserStorage = __importStar(require("./user-storage/index.cjs"));
+//# sourceMappingURL=index.cjs.map

package/dist/controllers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../src/controllers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6EAAmD;AACnD,wEAA8C","sourcesContent":["export * as Authentication from './authentication';\nexport * as UserStorage from './user-storage';\n"]}

package/dist/controllers/index.d.cts

@@ -0,0 +1,3 @@
+export * as Authentication from "./authentication/index.cjs";
+export * as UserStorage from "./user-storage/index.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/controllers/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/controllers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,mCAAyB;AACnD,OAAO,KAAK,WAAW,iCAAuB"}

package/dist/controllers/index.d.mts

@@ -0,0 +1,3 @@
+export * as Authentication from "./authentication/index.mjs";
+export * as UserStorage from "./user-storage/index.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/controllers/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/controllers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,mCAAyB;AACnD,OAAO,KAAK,WAAW,iCAAuB"}

package/dist/controllers/index.mjs

@@ -1,25 +1,3 @@
-import {
-  authentication_exports
-} from "../chunk-UHP2Y32K.mjs";
-import "../chunk-D4SNJOID.mjs";
-import "../chunk-LGXQBALM.mjs";
-import {
-  user_storage_exports
-} from "../chunk-2677XY6G.mjs";
-import "../chunk-SZ6WMC6C.mjs";
-import "../chunk-ZUPTMFEA.mjs";
-import "../chunk-EHZFPUJH.mjs";
-import "../chunk-NMIF3LSX.mjs";
-import "../chunk-76NMME23.mjs";
-import "../chunk-2VEMA6OE.mjs";
-import "../chunk-KHASG4H3.mjs";
-import "../chunk-COBJUBZE.mjs";
-import "../chunk-H25EBXG5.mjs";
-import "../chunk-76VRE4BI.mjs";
-import "../chunk-KTCSRECK.mjs";
-import "../chunk-U5UIDVOO.mjs";
-export {
-  authentication_exports as Authentication,
-  user_storage_exports as UserStorage
-};
+export * as Authentication from "./authentication/index.mjs";
+export * as UserStorage from "./user-storage/index.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/controllers/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/controllers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,mCAAyB;AACnD,OAAO,KAAK,WAAW,iCAAuB","sourcesContent":["export * as Authentication from './authentication';\nexport * as UserStorage from './user-storage';\n"]}

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

@@ -0,0 +1,462 @@
+"use strict";
+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 __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 _UserStorageController_instances, _UserStorageController_auth, _UserStorageController_accounts, _UserStorageController_config, _UserStorageController_notificationServices, _UserStorageController_isUnlocked, _UserStorageController_keyringController, _UserStorageController_nativeScryptCrypto, _UserStorageController_registerMessageHandlers, _UserStorageController_assertProfileSyncingEnabled, _UserStorageController_getStorageKeyAndBearerToken, _UserStorageController_createStorageKey, _UserStorageController__snapSignMessageCache, _UserStorageController_snapSignMessage, _UserStorageController_setIsProfileSyncingUpdateLoading;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultState = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const auth_snap_requests_1 = require("../authentication/auth-snap-requests.cjs");
+const user_storage_1 = require("./accounts/user-storage.cjs");
+const encryption_1 = require("./encryption/index.cjs");
+const controller_integration_1 = require("./network-syncing/controller-integration.cjs");
+const services_1 = require("./services.cjs");
+const controllerName = 'UserStorageController';
+exports.defaultState = {
+    isProfileSyncingEnabled: true,
+    isProfileSyncingUpdateLoading: false,
+};
+const metadata = {
+    isProfileSyncingEnabled: {
+        persist: true,
+        anonymous: true,
+    },
+    isProfileSyncingUpdateLoading: {
+        persist: false,
+        anonymous: false,
+    },
+};
+/**
+ * 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, env, config, getMetaMetricsState, nativeScryptCrypto, }) {
+        super({
+            messenger,
+            metadata,
+            name: controllerName,
+            state: { ...exports.defaultState, ...state },
+        });
+        _UserStorageController_instances.add(this);
+        _UserStorageController_auth.set(this, {
+            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');
+            },
+        });
+        _UserStorageController_accounts.set(this, {
+            // This is replaced with the actual value in the constructor
+            // We will remove this once the feature will be released
+            isAccountSyncingEnabled: false,
+            isAccountSyncingInProgress: false,
+            canSync: () => {
+                try {
+                    __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_assertProfileSyncingEnabled).call(this);
+                    return (__classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingEnabled && __classPrivateFieldGet(this, _UserStorageController_auth, "f").isAuthEnabled());
+                }
+                catch {
+                    return false;
+                }
+            },
+            setupAccountSyncingSubscriptions: () => {
+                this.messagingSystem.subscribe('AccountsController:accountAdded', 
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                async (account) => {
+                    if (__classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingInProgress) {
+                        return;
+                    }
+                    await this.saveInternalAccountToUserStorage(account);
+                });
+                this.messagingSystem.subscribe('AccountsController:accountRenamed', 
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                async (account) => {
+                    if (__classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingInProgress) {
+                        return;
+                    }
+                    await this.saveInternalAccountToUserStorage(account);
+                });
+            },
+            getInternalAccountsList: async () => {
+                return this.messagingSystem.call('AccountsController:listAccounts');
+            },
+            getUserStorageAccountsList: async () => {
+                const rawAccountsListResponse = await this.performGetStorageAllFeatureEntries('accounts');
+                return (rawAccountsListResponse?.map((rawAccount) => JSON.parse(rawAccount)) ??
+                    null);
+            },
+            saveInternalAccountToUserStorage: async (internalAccount) => {
+                // Map the internal account to the user storage account schema
+                const mappedAccount = (0, user_storage_1.mapInternalAccountToUserStorageAccount)(internalAccount);
+                await this.performSetStorage(`accounts.${internalAccount.address}`, JSON.stringify(mappedAccount));
+            },
+            saveInternalAccountsListToUserStorage: async () => {
+                const internalAccountsList = await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").getInternalAccountsList();
+                if (!internalAccountsList) {
+                    return;
+                }
+                const userStorageAccountsList = internalAccountsList.map(user_storage_1.mapInternalAccountToUserStorageAccount);
+                await Promise.all(userStorageAccountsList.map(async (userStorageAccount) => {
+                    await this.performSetStorage(`accounts.${userStorageAccount.a}`, JSON.stringify(userStorageAccount));
+                }));
+            },
+        });
+        _UserStorageController_config.set(this, void 0);
+        _UserStorageController_notificationServices.set(this, {
+            disableNotificationServices: async () => {
+                return await this.messagingSystem.call('NotificationServicesController:disableNotificationServices');
+            },
+            selectIsNotificationServicesEnabled: async () => {
+                return this.messagingSystem.call('NotificationServicesController:selectIsNotificationServicesEnabled');
+            },
+        });
+        _UserStorageController_isUnlocked.set(this, false);
+        _UserStorageController_keyringController.set(this, {
+            setupLockedStateSubscriptions: () => {
+                const { isUnlocked } = this.messagingSystem.call('KeyringController:getState');
+                __classPrivateFieldSet(this, _UserStorageController_isUnlocked, isUnlocked, "f");
+                this.messagingSystem.subscribe('KeyringController:unlock', () => {
+                    __classPrivateFieldSet(this, _UserStorageController_isUnlocked, true, "f");
+                });
+                this.messagingSystem.subscribe('KeyringController:lock', () => {
+                    __classPrivateFieldSet(this, _UserStorageController_isUnlocked, false, "f");
+                });
+            },
+        });
+        _UserStorageController_nativeScryptCrypto.set(this, undefined);
+        _UserStorageController__snapSignMessageCache.set(this, {});
+        __classPrivateFieldSet(this, _UserStorageController_config, config, "f");
+        __classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingEnabled = Boolean(env?.isAccountSyncingEnabled);
+        this.getMetaMetricsState = getMetaMetricsState;
+        __classPrivateFieldGet(this, _UserStorageController_keyringController, "f").setupLockedStateSubscriptions();
+        __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_registerMessageHandlers).call(this);
+        __classPrivateFieldSet(this, _UserStorageController_nativeScryptCrypto, nativeScryptCrypto, "f");
+        __classPrivateFieldGet(this, _UserStorageController_accounts, "f").setupAccountSyncingSubscriptions();
+        // Network Syncing
+        if (env?.isNetworkSyncingEnabled) {
+            (0, controller_integration_1.startNetworkSyncing)({
+                messenger,
+                getStorageConfig: async () => {
+                    const { storageKey, bearerToken } = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getStorageKeyAndBearerToken).call(this);
+                    return {
+                        storageKey,
+                        bearerToken,
+                        nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+                    };
+                },
+            });
+        }
+    }
+    async enableProfileSyncing() {
+        try {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).call(this, true);
+            const authEnabled = __classPrivateFieldGet(this, _UserStorageController_auth, "f").isAuthEnabled();
+            if (!authEnabled) {
+                await __classPrivateFieldGet(this, _UserStorageController_auth, "f").signIn();
+            }
+            this.update((state) => {
+                state.isProfileSyncingEnabled = true;
+            });
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).call(this, false);
+        }
+        catch (e) {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).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 {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).call(this, true);
+            const isNotificationServicesEnabled = await __classPrivateFieldGet(this, _UserStorageController_notificationServices, "f").selectIsNotificationServicesEnabled();
+            if (isNotificationServicesEnabled) {
+                await __classPrivateFieldGet(this, _UserStorageController_notificationServices, "f").disableNotificationServices();
+            }
+            const isMetaMetricsParticipation = this.getMetaMetricsState();
+            if (!isMetaMetricsParticipation) {
+                await __classPrivateFieldGet(this, _UserStorageController_auth, "f").signOut();
+            }
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).call(this, false);
+            this.update((state) => {
+                state.isProfileSyncingEnabled = false;
+            });
+        }
+        catch (e) {
+            __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_setIsProfileSyncingUpdateLoading).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 path - string in the form of `${feature}.${key}` that matches schema
+     * @returns the decrypted string contents found from user storage (or null if not found)
+     */
+    async performGetStorage(path) {
+        __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_assertProfileSyncingEnabled).call(this);
+        const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getStorageKeyAndBearerToken).call(this);
+        const result = await (0, services_1.getUserStorage)({
+            path,
+            bearerToken,
+            storageKey,
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+        });
+        return result;
+    }
+    /**
+     * 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
+     * @returns the array of decrypted string contents found from user storage (or null if not found)
+     */
+    async performGetStorageAllFeatureEntries(path) {
+        __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_assertProfileSyncingEnabled).call(this);
+        const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getStorageKeyAndBearerToken).call(this);
+        const result = await (0, services_1.getUserStorageAllFeatureEntries)({
+            path,
+            bearerToken,
+            storageKey,
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+        });
+        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 path - string in the form of `${feature}.${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(path, value) {
+        __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_assertProfileSyncingEnabled).call(this);
+        const { bearerToken, storageKey } = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_getStorageKeyAndBearerToken).call(this);
+        await (0, services_1.upsertUserStorage)(value, {
+            path,
+            bearerToken,
+            storageKey,
+            nativeScryptCrypto: __classPrivateFieldGet(this, _UserStorageController_nativeScryptCrypto, "f"),
+        });
+    }
+    /**
+     * Retrieves the storage key, for internal use only!
+     *
+     * @returns the storage key
+     */
+    async getStorageKey() {
+        __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_assertProfileSyncingEnabled).call(this);
+        const storageKey = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_createStorageKey).call(this);
+        return storageKey;
+    }
+    /**
+     * Syncs the internal accounts list with the user storage accounts list.
+     * This method is used to make sure that the internal accounts list is up-to-date with the user storage accounts list and vice-versa.
+     * It will add new accounts to the internal accounts list, update/merge conflicting names and re-upload the results in some cases to the user storage.
+     */
+    async syncInternalAccountsWithUserStorage() {
+        if (!__classPrivateFieldGet(this, _UserStorageController_accounts, "f").canSync()) {
+            return;
+        }
+        try {
+            __classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingInProgress = true;
+            const profileId = await __classPrivateFieldGet(this, _UserStorageController_auth, "f").getProfileId();
+            const userStorageAccountsList = await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").getUserStorageAccountsList();
+            if (!userStorageAccountsList || !userStorageAccountsList.length) {
+                await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountsListToUserStorage();
+                return;
+            }
+            // Compare internal accounts list with user storage accounts list
+            // First step: compare lengths
+            let internalAccountsList = await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").getInternalAccountsList();
+            if (!internalAccountsList || !internalAccountsList.length) {
+                throw new Error(`Failed to get internal accounts list`);
+            }
+            const hasMoreInternalAccountsThanUserStorageAccounts = internalAccountsList.length > userStorageAccountsList.length;
+            // We don't want to remove existing accounts for a user
+            // so we only add new accounts if the user has more accounts than the internal accounts list
+            if (!hasMoreInternalAccountsThanUserStorageAccounts) {
+                const numberOfAccountsToAdd = userStorageAccountsList.length - internalAccountsList.length;
+                // Create new accounts to match the user storage accounts list
+                const addNewAccountsPromises = Array.from({
+                    length: numberOfAccountsToAdd,
+                }).map(async () => {
+                    await this.messagingSystem.call('KeyringController:addNewAccount');
+                    __classPrivateFieldGet(this, _UserStorageController_config, "f")?.accountSyncing?.onAccountAdded?.(profileId);
+                });
+                await Promise.all(addNewAccountsPromises);
+            }
+            // Second step: compare account names
+            // Get the internal accounts list again since new accounts might have been added in the previous step
+            internalAccountsList = await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").getInternalAccountsList();
+            for await (const internalAccount of internalAccountsList) {
+                const userStorageAccount = userStorageAccountsList.find((account) => account.a === internalAccount.address);
+                if (!userStorageAccount) {
+                    await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountToUserStorage(internalAccount);
+                    continue;
+                }
+                // One or both accounts have default names
+                const isInternalAccountNameDefault = (0, user_storage_1.isNameDefaultAccountName)(internalAccount.metadata.name);
+                const isUserStorageAccountNameDefault = (0, user_storage_1.isNameDefaultAccountName)(userStorageAccount.n);
+                // Internal account has default name
+                if (isInternalAccountNameDefault) {
+                    if (!isUserStorageAccountNameDefault) {
+                        this.messagingSystem.call('AccountsController:updateAccountMetadata', internalAccount.id, {
+                            name: userStorageAccount.n,
+                        });
+                        __classPrivateFieldGet(this, _UserStorageController_config, "f")?.accountSyncing?.onAccountNameUpdated?.(profileId);
+                    }
+                    continue;
+                }
+                // Internal account has custom name but user storage account has default name
+                if (isUserStorageAccountNameDefault) {
+                    await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountToUserStorage(internalAccount);
+                    continue;
+                }
+                // Both accounts have custom names
+                // User storage account has a nameLastUpdatedAt timestamp
+                // Note: not storing the undefined checks in constants to act as a type guard
+                if (userStorageAccount.nlu !== undefined) {
+                    if (internalAccount.metadata.nameLastUpdatedAt !== undefined) {
+                        const isInternalAccountNameNewer = internalAccount.metadata.nameLastUpdatedAt >
+                            userStorageAccount.nlu;
+                        if (isInternalAccountNameNewer) {
+                            await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountToUserStorage(internalAccount);
+                            continue;
+                        }
+                    }
+                    this.messagingSystem.call('AccountsController:updateAccountMetadata', internalAccount.id, {
+                        name: userStorageAccount.n,
+                        nameLastUpdatedAt: userStorageAccount.nlu,
+                    });
+                    __classPrivateFieldGet(this, _UserStorageController_config, "f")?.accountSyncing?.onAccountNameUpdated?.(profileId);
+                    continue;
+                }
+                else if (internalAccount.metadata.nameLastUpdatedAt !== undefined) {
+                    await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountToUserStorage(internalAccount);
+                    continue;
+                }
+            }
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+            throw new Error(`${controllerName} - failed to sync user storage accounts list - ${errorMessage}`);
+        }
+        finally {
+            __classPrivateFieldGet(this, _UserStorageController_accounts, "f").isAccountSyncingInProgress = false;
+        }
+    }
+    /**
+     * Saves an individual internal account to the user storage.
+     * @param internalAccount - The internal account to save
+     */
+    async saveInternalAccountToUserStorage(internalAccount) {
+        if (!__classPrivateFieldGet(this, _UserStorageController_accounts, "f").canSync()) {
+            return;
+        }
+        try {
+            await __classPrivateFieldGet(this, _UserStorageController_accounts, "f").saveInternalAccountToUserStorage(internalAccount);
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
+            throw new Error(`${controllerName} - failed to save account to user storage - ${errorMessage}`);
+        }
+    }
+}
+_UserStorageController_auth = new WeakMap(), _UserStorageController_accounts = new WeakMap(), _UserStorageController_config = new WeakMap(), _UserStorageController_notificationServices = new WeakMap(), _UserStorageController_isUnlocked = new WeakMap(), _UserStorageController_keyringController = new WeakMap(), _UserStorageController_nativeScryptCrypto = new WeakMap(), _UserStorageController__snapSignMessageCache = new WeakMap(), _UserStorageController_instances = new WeakSet(), _UserStorageController_registerMessageHandlers = function _UserStorageController_registerMessageHandlers() {
+    this.messagingSystem.registerActionHandler('UserStorageController:performGetStorage', this.performGetStorage.bind(this));
+    this.messagingSystem.registerActionHandler('UserStorageController:performGetStorageAllFeatureEntries', this.performGetStorageAllFeatureEntries.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));
+    this.messagingSystem.registerActionHandler('UserStorageController:syncInternalAccountsWithUserStorage', this.syncInternalAccountsWithUserStorage.bind(this));
+    this.messagingSystem.registerActionHandler('UserStorageController:saveInternalAccountToUserStorage', this.saveInternalAccountToUserStorage.bind(this));
+}, _UserStorageController_assertProfileSyncingEnabled = function _UserStorageController_assertProfileSyncingEnabled() {
+    if (!this.state.isProfileSyncingEnabled) {
+        throw new Error(`${controllerName}: Unable to call method, user is not authenticated`);
+    }
+}, _UserStorageController_getStorageKeyAndBearerToken = 
+/**
+ * Utility to get the bearer token and storage key
+ */
+async function _UserStorageController_getStorageKeyAndBearerToken() {
+    const bearerToken = await __classPrivateFieldGet(this, _UserStorageController_auth, "f").getBearerToken();
+    if (!bearerToken) {
+        throw new Error('UserStorageController - unable to get bearer token');
+    }
+    const storageKey = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_createStorageKey).call(this);
+    return { bearerToken, storageKey };
+}, _UserStorageController_createStorageKey = 
+/**
+ * Rather than storing the storage key, we can compute the storage key when needed.
+ *
+ * @returns the storage key
+ */
+async function _UserStorageController_createStorageKey() {
+    const id = await __classPrivateFieldGet(this, _UserStorageController_auth, "f").getProfileId();
+    if (!id) {
+        throw new Error('UserStorageController - unable to create storage key');
+    }
+    const storageKeySignature = await __classPrivateFieldGet(this, _UserStorageController_instances, "m", _UserStorageController_snapSignMessage).call(this, `metamask:${id}`);
+    const storageKey = (0, encryption_1.createSHA256Hash)(storageKeySignature);
+    return storageKey;
+}, _UserStorageController_snapSignMessage = 
+/**
+ * Signs a specific message using an underlying auth snap.
+ *
+ * @param message - A specific tagged message to sign.
+ * @returns A Signature created by the snap.
+ */
+async function _UserStorageController_snapSignMessage(message) {
+    if (__classPrivateFieldGet(this, _UserStorageController__snapSignMessageCache, "f")[message]) {
+        return __classPrivateFieldGet(this, _UserStorageController__snapSignMessageCache, "f")[message];
+    }
+    if (!__classPrivateFieldGet(this, _UserStorageController_isUnlocked, "f")) {
+        throw new Error('#snapSignMessage - unable to call snap, wallet is locked');
+    }
+    const result = (await this.messagingSystem.call('SnapController:handleRequest', (0, auth_snap_requests_1.createSnapSignMessageRequest)(message)));
+    __classPrivateFieldGet(this, _UserStorageController__snapSignMessageCache, "f")[message] = result;
+    return result;
+}, _UserStorageController_setIsProfileSyncingUpdateLoading = function _UserStorageController_setIsProfileSyncingUpdateLoading(isProfileSyncingUpdateLoading) {
+    this.update((state) => {
+        state.isProfileSyncingUpdateLoading = isProfileSyncingUpdateLoading;
+    });
+};
+exports.default = UserStorageController;
+//# sourceMappingURL=UserStorageController.cjs.map