@metamask/snaps-controllers 9.5.0 → 9.6.0

package/dist/snaps/SnapController.cjs

@@ -0,0 +1,1896 @@
+"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 _SnapController_instances, _SnapController_closeAllConnections, _SnapController_dynamicPermissions, _SnapController_environmentEndowmentPermissions, _SnapController_excludedPermissions, _SnapController_featureFlags, _SnapController_fetchFunction, _SnapController_idleTimeCheckInterval, _SnapController_maxIdleTime, _SnapController_encryptor, _SnapController_getMnemonic, _SnapController_getFeatureFlags, _SnapController_detectSnapLocation, _SnapController_snapsRuntimeData, _SnapController_rollbackSnapshots, _SnapController_timeoutForLastRequestStatus, _SnapController_statusMachine, _SnapController_preinstalledSnaps, _SnapController_initializeStateMachine, _SnapController_registerMessageHandlers, _SnapController_handlePreinstalledSnaps, _SnapController_pollForLastRequestStatus, _SnapController_blockSnap, _SnapController_unblockSnap, _SnapController_assertIsInstallAllowed, _SnapController_assertCanInstallSnaps, _SnapController_assertCanUsePlatform, _SnapController_stopSnapsLastRequestPastMax, _SnapController_transition, _SnapController_terminateSnap, _SnapController_getSnapEncryptionKey, _SnapController_decryptSnapState, _SnapController_encryptSnapState, _SnapController_handleInitialConnections, _SnapController_addSnapToSubject, _SnapController_removeSnapFromSubjects, _SnapController_revokeAllSnapPermissions, _SnapController_createApproval, _SnapController_updateApproval, _SnapController_resolveAllowlistVersion, _SnapController_add, _SnapController_startSnap, _SnapController_getEndowments, _SnapController_set, _SnapController_validateSnapPermissions, _SnapController_getExecutionTimeout, _SnapController_getRpcRequestHandler, _SnapController_createInterface, _SnapController_assertInterfaceExists, _SnapController_transformSnapRpcRequestResult, _SnapController_assertSnapRpcRequestResult, _SnapController_recordSnapRpcRequestStart, _SnapController_recordSnapRpcRequestFinish, _SnapController_getRollbackSnapshot, _SnapController_createRollbackSnapshot, _SnapController_rollbackSnap, _SnapController_rollbackSnaps, _SnapController_getRuntime, _SnapController_getRuntimeExpect, _SnapController_setupRuntime, _SnapController_calculatePermissionsChange, _SnapController_isSubjectConnectedToSnap, _SnapController_calculateConnectionsChange, _SnapController_updatePermissions, _SnapController_isValidUpdate, _SnapController_callLifecycleHook;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapController = exports.SNAP_APPROVAL_RESULT = exports.SNAP_APPROVAL_UPDATE = exports.SNAP_APPROVAL_INSTALL = exports.controllerName = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const permission_controller_1 = require("@metamask/permission-controller");
+const rpc_errors_1 = require("@metamask/rpc-errors");
+const snaps_rpc_methods_1 = require("@metamask/snaps-rpc-methods");
+const snaps_sdk_1 = require("@metamask/snaps-sdk");
+const snaps_utils_1 = require("@metamask/snaps-utils");
+const utils_1 = require("@metamask/utils");
+const fsm_1 = require("@xstate/fsm");
+const nanoid_1 = require("nanoid");
+const fsm_2 = require("../fsm.cjs");
+const logging_1 = require("../logging.cjs");
+const utils_2 = require("../utils.cjs");
+const constants_1 = require("./constants.cjs");
+const location_1 = require("./location/index.cjs");
+const registry_1 = require("./registry/index.cjs");
+const RequestQueue_1 = require("./RequestQueue.cjs");
+const Timer_1 = require("./Timer.cjs");
+exports.controllerName = 'SnapController';
+// TODO: Figure out how to name these
+exports.SNAP_APPROVAL_INSTALL = 'wallet_installSnap';
+exports.SNAP_APPROVAL_UPDATE = 'wallet_updateSnap';
+exports.SNAP_APPROVAL_RESULT = 'wallet_installSnapResult';
+const TRUNCATED_SNAP_PROPERTIES = new Set([
+    'initialPermissions',
+    'id',
+    'version',
+    'enabled',
+    'blocked',
+]);
+const defaultState = {
+    snaps: {},
+    snapStates: {},
+    unencryptedSnapStates: {},
+};
+/**
+ * Truncates the properties of a snap to only ones that are easily serializable.
+ *
+ * @param snap - The snap to truncate.
+ * @returns Object with serializable snap properties.
+ */
+function truncateSnap(snap) {
+    const truncatedSnap = Object.keys(snap).reduce((serialized, key) => {
+        if (TRUNCATED_SNAP_PROPERTIES.has(key)) {
+            serialized[key] = snap[key];
+        }
+        return serialized;
+    }, {});
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    return truncatedSnap;
+}
+const name = 'SnapController';
+/*
+ * A snap is initialized in three phases:
+ * - Add: Loads the snap from a remote source and parses it.
+ * - Authorize: Requests the snap's required permissions from the user.
+ * - Start: Initializes the snap in its SES realm with the authorized permissions.
+ */
+class SnapController extends base_controller_1.BaseController {
+    constructor({ closeAllConnections, messenger, state, dynamicPermissions = ['eth_accounts'], environmentEndowmentPermissions = [], excludedPermissions = {}, idleTimeCheckInterval = (0, utils_1.inMilliseconds)(5, utils_1.Duration.Second), maxIdleTime = (0, utils_1.inMilliseconds)(30, utils_1.Duration.Second), maxRequestTime = (0, utils_1.inMilliseconds)(60, utils_1.Duration.Second), fetchFunction = globalThis.fetch.bind(undefined), featureFlags = {}, detectSnapLocation: detectSnapLocationFunction = location_1.detectSnapLocation, preinstalledSnaps = null, encryptor, getMnemonic, getFeatureFlags = () => ({}), }) {
+        super({
+            messenger,
+            metadata: {
+                snapStates: {
+                    persist: true,
+                    anonymous: false,
+                },
+                unencryptedSnapStates: {
+                    persist: true,
+                    anonymous: false,
+                },
+                snaps: {
+                    persist: (snaps) => {
+                        return (Object.values(snaps)
+                            // We should not persist snaps that are in the installing state,
+                            // since they haven't completed installation and would be unusable
+                            .filter((snap) => snap.status !== snaps_utils_1.SnapStatus.Installing)
+                            .map((snap) => {
+                            return {
+                                ...snap,
+                                // At the time state is rehydrated, no snap will be running.
+                                status: snaps_utils_1.SnapStatus.Stopped,
+                            };
+                        })
+                            .reduce((memo, snap) => {
+                            memo[snap.id] = snap;
+                            return memo;
+                        }, {}));
+                    },
+                    anonymous: false,
+                },
+            },
+            name,
+            state: {
+                ...defaultState,
+                ...state,
+            },
+        });
+        _SnapController_instances.add(this);
+        _SnapController_closeAllConnections.set(this, void 0);
+        _SnapController_dynamicPermissions.set(this, void 0);
+        _SnapController_environmentEndowmentPermissions.set(this, void 0);
+        _SnapController_excludedPermissions.set(this, void 0);
+        _SnapController_featureFlags.set(this, void 0);
+        _SnapController_fetchFunction.set(this, void 0);
+        _SnapController_idleTimeCheckInterval.set(this, void 0);
+        _SnapController_maxIdleTime.set(this, void 0);
+        _SnapController_encryptor.set(this, void 0);
+        _SnapController_getMnemonic.set(this, void 0);
+        _SnapController_getFeatureFlags.set(this, void 0);
+        _SnapController_detectSnapLocation.set(this, void 0);
+        _SnapController_snapsRuntimeData.set(this, void 0);
+        _SnapController_rollbackSnapshots.set(this, void 0);
+        _SnapController_timeoutForLastRequestStatus.set(this, void 0);
+        _SnapController_statusMachine.set(this, void 0);
+        _SnapController_preinstalledSnaps.set(this, void 0);
+        __classPrivateFieldSet(this, _SnapController_closeAllConnections, closeAllConnections, "f");
+        __classPrivateFieldSet(this, _SnapController_dynamicPermissions, dynamicPermissions, "f");
+        __classPrivateFieldSet(this, _SnapController_environmentEndowmentPermissions, environmentEndowmentPermissions, "f");
+        __classPrivateFieldSet(this, _SnapController_excludedPermissions, excludedPermissions, "f");
+        __classPrivateFieldSet(this, _SnapController_featureFlags, featureFlags, "f");
+        __classPrivateFieldSet(this, _SnapController_fetchFunction, fetchFunction, "f");
+        __classPrivateFieldSet(this, _SnapController_idleTimeCheckInterval, idleTimeCheckInterval, "f");
+        __classPrivateFieldSet(this, _SnapController_maxIdleTime, maxIdleTime, "f");
+        this.maxRequestTime = maxRequestTime;
+        __classPrivateFieldSet(this, _SnapController_detectSnapLocation, detectSnapLocationFunction, "f");
+        __classPrivateFieldSet(this, _SnapController_encryptor, encryptor, "f");
+        __classPrivateFieldSet(this, _SnapController_getMnemonic, getMnemonic, "f");
+        __classPrivateFieldSet(this, _SnapController_getFeatureFlags, getFeatureFlags, "f");
+        __classPrivateFieldSet(this, _SnapController_preinstalledSnaps, preinstalledSnaps, "f");
+        this._onUnhandledSnapError = this._onUnhandledSnapError.bind(this);
+        this._onOutboundRequest = this._onOutboundRequest.bind(this);
+        this._onOutboundResponse = this._onOutboundResponse.bind(this);
+        __classPrivateFieldSet(this, _SnapController_rollbackSnapshots, new Map(), "f");
+        __classPrivateFieldSet(this, _SnapController_snapsRuntimeData, new Map(), "f");
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_pollForLastRequestStatus).call(this);
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.messagingSystem.subscribe('ExecutionService:unhandledError', this._onUnhandledSnapError);
+        this.messagingSystem.subscribe('ExecutionService:outboundRequest', this._onOutboundRequest);
+        this.messagingSystem.subscribe('ExecutionService:outboundResponse', this._onOutboundResponse);
+        /* eslint-enable @typescript-eslint/unbound-method */
+        this.messagingSystem.subscribe('SnapController:snapInstalled', ({ id }, origin) => {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_callLifecycleHook).call(this, origin, id, snaps_utils_1.HandlerType.OnInstall).catch((error) => {
+                (0, snaps_utils_1.logError)(`Error when calling \`onInstall\` lifecycle hook for snap "${id}": ${(0, snaps_sdk_1.getErrorMessage)(error)}`);
+            });
+        });
+        this.messagingSystem.subscribe('SnapController:snapUpdated', ({ id }, _oldVersion, origin) => {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_callLifecycleHook).call(this, origin, id, snaps_utils_1.HandlerType.OnUpdate).catch((error) => {
+                (0, snaps_utils_1.logError)(`Error when calling \`onUpdate\` lifecycle hook for snap "${id}": ${(0, snaps_sdk_1.getErrorMessage)(error)}`);
+            });
+        });
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_initializeStateMachine).call(this);
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_registerMessageHandlers).call(this);
+        if (__classPrivateFieldGet(this, _SnapController_preinstalledSnaps, "f")) {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_handlePreinstalledSnaps).call(this, __classPrivateFieldGet(this, _SnapController_preinstalledSnaps, "f"));
+        }
+        Object.values(this.state?.snaps ?? {}).forEach((snap) => __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_setupRuntime).call(this, snap.id));
+    }
+    /**
+     * Checks all installed snaps against the block list and
+     * blocks/unblocks snaps as appropriate. See {@link SnapController.blockSnap}
+     * for more information.
+     */
+    async updateBlockedSnaps() {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        await this.messagingSystem.call('SnapsRegistry:update');
+        const blockedSnaps = await this.messagingSystem.call('SnapsRegistry:get', Object.values(this.state.snaps).reduce((blockListArg, snap) => {
+            blockListArg[snap.id] = {
+                version: snap.version,
+                checksum: snap.manifest.source.shasum,
+            };
+            return blockListArg;
+        }, {}));
+        await Promise.all(Object.entries(blockedSnaps).map(async ([snapId, { status, reason }]) => {
+            if (status === registry_1.SnapsRegistryStatus.Blocked) {
+                return __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_blockSnap).call(this, snapId, reason);
+            }
+            return __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_unblockSnap).call(this, snapId);
+        }));
+    }
+    _onUnhandledSnapError(snapId, _error) {
+        this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Crash).catch((stopSnapError) => {
+            // TODO: Decide how to handle errors.
+            (0, snaps_utils_1.logError)(stopSnapError);
+        });
+    }
+    _onOutboundRequest(snapId) {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+        // Ideally we would only pause the pending request that is making the outbound request
+        // but right now we don't have a way to know which request initiated the outbound request
+        runtime.pendingInboundRequests
+            .filter((pendingRequest) => pendingRequest.timer.status === 'running')
+            .forEach((pendingRequest) => pendingRequest.timer.pause());
+        runtime.pendingOutboundRequests += 1;
+    }
+    _onOutboundResponse(snapId) {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+        runtime.pendingOutboundRequests -= 1;
+        if (runtime.pendingOutboundRequests === 0) {
+            runtime.pendingInboundRequests
+                .filter((pendingRequest) => pendingRequest.timer.status === 'paused')
+                .forEach((pendingRequest) => pendingRequest.timer.resume());
+        }
+    }
+    /**
+     * Starts the given snap. Throws an error if no such snap exists
+     * or if it is already running.
+     *
+     * @param snapId - The id of the Snap to start.
+     */
+    async startSnap(snapId) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        const snap = this.state.snaps[snapId];
+        if (snap.enabled === false) {
+            throw new Error(`Snap "${snapId}" is disabled.`);
+        }
+        await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_startSnap).call(this, {
+            snapId,
+            sourceCode: snap.sourceCode,
+        });
+    }
+    /**
+     * Enables the given snap. A snap can only be started if it is enabled. A snap
+     * can only be enabled if it isn't blocked.
+     *
+     * @param snapId - The id of the Snap to enable.
+     */
+    enableSnap(snapId) {
+        this.getExpect(snapId);
+        if (this.state.snaps[snapId].blocked) {
+            throw new Error(`Snap "${snapId}" is blocked and cannot be enabled.`);
+        }
+        this.update((state) => {
+            state.snaps[snapId].enabled = true;
+        });
+        this.messagingSystem.publish('SnapController:snapEnabled', this.getTruncatedExpect(snapId));
+    }
+    /**
+     * Disables the given snap. A snap can only be started if it is enabled.
+     *
+     * @param snapId - The id of the Snap to disable.
+     * @returns A promise that resolves once the snap has been disabled.
+     */
+    async disableSnap(snapId) {
+        if (!this.has(snapId)) {
+            throw new Error(`Snap "${snapId}" not found.`);
+        }
+        this.update((state) => {
+            state.snaps[snapId].enabled = false;
+        });
+        if (this.isRunning(snapId)) {
+            await this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Stop);
+        }
+        this.messagingSystem.publish('SnapController:snapDisabled', this.getTruncatedExpect(snapId));
+    }
+    /**
+     * Stops the given snap, removes all hooks, closes all connections, and
+     * terminates its worker.
+     *
+     * @param snapId - The id of the Snap to stop.
+     * @param statusEvent - The Snap status event that caused the snap to be
+     * stopped.
+     */
+    async stopSnap(snapId, statusEvent = snaps_utils_1.SnapStatusEvents.Stop) {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntime).call(this, snapId);
+        if (!runtime) {
+            throw new Error(`The snap "${snapId}" is not running.`);
+        }
+        // No-op if the Snap is already stopping.
+        if (runtime.stopping) {
+            return;
+        }
+        // Flag that the Snap is actively stopping, this prevents other calls to stopSnap
+        // while we are handling termination of the Snap
+        runtime.stopping = true;
+        try {
+            if (this.isRunning(snapId)) {
+                __classPrivateFieldGet(this, _SnapController_closeAllConnections, "f")?.call(this, snapId);
+                await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_terminateSnap).call(this, snapId);
+            }
+        }
+        finally {
+            // Reset request tracking
+            runtime.lastRequest = null;
+            runtime.pendingInboundRequests = [];
+            runtime.pendingOutboundRequests = 0;
+            runtime.stopping = false;
+            if (this.isRunning(snapId)) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_transition).call(this, snapId, statusEvent);
+            }
+        }
+    }
+    /**
+     * Stops all running snaps, removes all hooks, closes all connections, and
+     * terminates their workers.
+     *
+     * @param statusEvent - The Snap status event that caused the snap to be
+     * stopped.
+     */
+    async stopAllSnaps(statusEvent = snaps_utils_1.SnapStatusEvents.Stop) {
+        const snaps = Object.values(this.state.snaps).filter((snap) => this.isRunning(snap.id));
+        const promises = snaps.map(async (snap) => this.stopSnap(snap.id, statusEvent));
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Returns whether the given snap is running.
+     * Throws an error if the snap doesn't exist.
+     *
+     * @param snapId - The id of the Snap to check.
+     * @returns `true` if the snap is running, otherwise `false`.
+     */
+    isRunning(snapId) {
+        return this.getExpect(snapId).status === 'running';
+    }
+    /**
+     * Returns whether the given snap has been added to state.
+     *
+     * @param snapId - The id of the Snap to check for.
+     * @returns `true` if the snap exists in the controller state, otherwise `false`.
+     */
+    has(snapId) {
+        return Boolean(this.get(snapId));
+    }
+    /**
+     * Gets the snap with the given id if it exists, including all data.
+     * This should not be used if the snap is to be serializable, as e.g.
+     * the snap sourceCode may be quite large.
+     *
+     * @param snapId - The id of the Snap to get.
+     * @returns The entire snap object from the controller state.
+     */
+    get(snapId) {
+        return this.state.snaps[snapId];
+    }
+    /**
+     * Gets the snap with the given id, throws if doesn't.
+     * This should not be used if the snap is to be serializable, as e.g.
+     * the snap sourceCode may be quite large.
+     *
+     * @see {@link SnapController.get}
+     * @throws {@link Error}. If the snap doesn't exist
+     * @param snapId - The id of the snap to get.
+     * @returns The entire snap object.
+     */
+    getExpect(snapId) {
+        const snap = this.get(snapId);
+        (0, utils_1.assert)(snap !== undefined, new Error(`Snap "${snapId}" not found.`));
+        return snap;
+    }
+    /**
+     * Gets the snap with the given id if it exists, excluding any
+     * non-serializable or expensive-to-serialize data.
+     *
+     * @param snapId - The id of the Snap to get.
+     * @returns A truncated version of the snap state, that is less expensive to serialize.
+     */
+    // TODO(ritave): this.get returns undefined, this.getTruncated returns null
+    getTruncated(snapId) {
+        const snap = this.get(snapId);
+        return snap ? truncateSnap(snap) : null;
+    }
+    /**
+     * Gets the snap with the given id, throw if it doesn't exist.
+     *
+     * @throws {@link Error}. If snap doesn't exist
+     * @param snapId - The id of the snap to get.
+     * @returns A truncated version of the snap state, that is less expensive to serialize.
+     */
+    getTruncatedExpect(snapId) {
+        return truncateSnap(this.getExpect(snapId));
+    }
+    /**
+     * Updates the own state of the snap with the given id.
+     * This is distinct from the state MetaMask uses to manage snaps.
+     *
+     * @param snapId - The id of the Snap whose state should be updated.
+     * @param newSnapState - The new state of the snap.
+     * @param encrypted - A flag to indicate whether to use encrypted storage or not.
+     */
+    async updateSnapState(snapId, newSnapState, encrypted) {
+        if (encrypted) {
+            const encryptedState = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_encryptSnapState).call(this, snapId, newSnapState);
+            this.update((state) => {
+                state.snapStates[snapId] = encryptedState;
+            });
+        }
+        else {
+            this.update((state) => {
+                state.unencryptedSnapStates[snapId] = JSON.stringify(newSnapState);
+            });
+        }
+    }
+    /**
+     * Clears the state of the snap with the given id.
+     * This is distinct from the state MetaMask uses to manage snaps.
+     *
+     * @param snapId - The id of the Snap whose state should be cleared.
+     * @param encrypted - A flag to indicate whether to use encrypted storage or not.
+     */
+    clearSnapState(snapId, encrypted) {
+        this.update((state) => {
+            if (encrypted) {
+                state.snapStates[snapId] = null;
+            }
+            else {
+                state.unencryptedSnapStates[snapId] = null;
+            }
+        });
+    }
+    /**
+     * Gets the own state of the snap with the given id.
+     * This is distinct from the state MetaMask uses to manage snaps.
+     *
+     * @param snapId - The id of the Snap whose state to get.
+     * @param encrypted - A flag to indicate whether to use encrypted storage or not.
+     * @returns The requested snap state or null if no state exists.
+     */
+    async getSnapState(snapId, encrypted) {
+        const state = encrypted
+            ? this.state.snapStates[snapId]
+            : this.state.unencryptedSnapStates[snapId];
+        if (state === null || state === undefined) {
+            return null;
+        }
+        if (!encrypted) {
+            return (0, snaps_utils_1.parseJson)(state);
+        }
+        const decrypted = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_decryptSnapState).call(this, snapId, state);
+        return decrypted;
+    }
+    /**
+     * Gets a static auxiliary snap file in a chosen file encoding.
+     *
+     * @param snapId - The id of the Snap whose state to get.
+     * @param path - The path to the requested file.
+     * @param encoding - An optional requested file encoding.
+     * @returns The file requested in the chosen file encoding or null if the file is not found.
+     */
+    async getSnapFile(snapId, path, encoding = snaps_sdk_1.AuxiliaryFileEncoding.Base64) {
+        const snap = this.getExpect(snapId);
+        const normalizedPath = (0, snaps_utils_1.normalizeRelative)(path);
+        const value = snap.auxiliaryFiles?.find((file) => file.path === normalizedPath)?.value;
+        if (!value) {
+            return null;
+        }
+        const encoded = await (0, snaps_utils_1.encodeAuxiliaryFile)(value, encoding);
+        (0, utils_1.assert)(encoded.length < snaps_utils_1.MAX_FILE_SIZE, `Failed to encode static file to "${encoding}": Static files must be less than 64 MB when encoded.`);
+        return encoded;
+    }
+    /**
+     * Completely clear the controller's state: delete all associated data,
+     * handlers, event listeners, and permissions; tear down all snap providers.
+     */
+    async clearState() {
+        const snapIds = Object.keys(this.state.snaps);
+        if (__classPrivateFieldGet(this, _SnapController_closeAllConnections, "f")) {
+            snapIds.forEach((snapId) => {
+                __classPrivateFieldGet(this, _SnapController_closeAllConnections, "f")?.call(this, snapId);
+            });
+        }
+        await this.messagingSystem.call('ExecutionService:terminateAllSnaps');
+        snapIds.forEach((snapId) => __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_revokeAllSnapPermissions).call(this, snapId));
+        this.update((state) => {
+            state.snaps = {};
+            state.snapStates = {};
+        });
+        __classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").clear();
+        // We want to remove all snaps & permissions, except for preinstalled snaps
+        if (__classPrivateFieldGet(this, _SnapController_preinstalledSnaps, "f")) {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_handlePreinstalledSnaps).call(this, __classPrivateFieldGet(this, _SnapController_preinstalledSnaps, "f"));
+            Object.values(this.state?.snaps).forEach((snap) => __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_setupRuntime).call(this, snap.id));
+        }
+    }
+    /**
+     * Removes the given snap from state, and clears all associated handlers
+     * and listeners.
+     *
+     * @param snapId - The id of the Snap.
+     * @returns A promise that resolves once the snap has been removed.
+     */
+    async removeSnap(snapId) {
+        return this.removeSnaps([snapId]);
+    }
+    /**
+     * Stops the given snaps, removes them from state, and clears all associated
+     * permissions, handlers, and listeners.
+     *
+     * @param snapIds - The ids of the Snaps.
+     */
+    async removeSnaps(snapIds) {
+        if (!Array.isArray(snapIds)) {
+            throw new Error('Expected array of snap ids.');
+        }
+        snapIds.forEach((snapId) => {
+            const snap = this.getExpect(snapId);
+            (0, utils_1.assert)(snap.removable !== false, `${snapId} is not removable.`);
+        });
+        await Promise.all(snapIds.map(async (snapId) => {
+            const snap = this.getExpect(snapId);
+            const truncated = this.getTruncatedExpect(snapId);
+            // Disable the snap and revoke all of its permissions before deleting
+            // it. This ensures that the snap will not be restarted or otherwise
+            // affect the host environment while we are deleting it.
+            await this.disableSnap(snapId);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_revokeAllSnapPermissions).call(this, snapId);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_removeSnapFromSubjects).call(this, snapId);
+            __classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").delete(snapId);
+            this.update((state) => {
+                delete state.snaps[snapId];
+                delete state.snapStates[snapId];
+                delete state.unencryptedSnapStates[snapId];
+            });
+            // If the snap has been fully installed before, also emit snapUninstalled.
+            if (snap.status !== snaps_utils_1.SnapStatus.Installing) {
+                this.messagingSystem.publish(`SnapController:snapUninstalled`, truncated);
+            }
+        }));
+    }
+    /**
+     * Removes a snap's permission (caveat) from the specified subject.
+     *
+     * @param origin - The origin from which to remove the snap.
+     * @param snapId - The id of the snap to remove.
+     */
+    removeSnapFromSubject(origin, snapId) {
+        const subjectPermissions = this.messagingSystem.call('PermissionController:getPermissions', origin);
+        const snapIdsCaveat = subjectPermissions?.[snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat) => caveat.type === snaps_utils_1.SnapCaveatType.SnapIds);
+        if (!snapIdsCaveat) {
+            return;
+        }
+        const caveatHasSnap = Boolean(snapIdsCaveat.value?.[snapId]);
+        if (caveatHasSnap) {
+            const newCaveatValue = {
+                ...snapIdsCaveat.value,
+            };
+            delete newCaveatValue[snapId];
+            if (Object.keys(newCaveatValue).length > 0) {
+                this.messagingSystem.call('PermissionController:updateCaveat', origin, snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY, snaps_utils_1.SnapCaveatType.SnapIds, newCaveatValue);
+            }
+            else {
+                this.messagingSystem.call('PermissionController:revokePermissions', {
+                    [origin]: [snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY],
+                });
+            }
+        }
+    }
+    /**
+     * Checks if a list of permissions are dynamic and allowed to be revoked, if they are they will all be revoked.
+     *
+     * @param snapId - The snap ID.
+     * @param permissionNames - The names of the permissions.
+     * @throws If non-dynamic permissions are passed.
+     */
+    revokeDynamicSnapPermissions(snapId, permissionNames) {
+        (0, utils_1.assert)(permissionNames.every((permissionName) => __classPrivateFieldGet(this, _SnapController_dynamicPermissions, "f").includes(permissionName)), 'Non-dynamic permissions cannot be revoked');
+        this.messagingSystem.call('PermissionController:revokePermissions', {
+            [snapId]: permissionNames,
+        });
+    }
+    /**
+     * Handles incrementing the activeReferences counter.
+     *
+     * @param snapId - The snap id of the snap that was referenced.
+     */
+    incrementActiveReferences(snapId) {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+        runtime.activeReferences += 1;
+    }
+    /**
+     * Handles decrement the activeReferences counter.
+     *
+     * @param snapId - The snap id of the snap that was referenced..
+     */
+    decrementActiveReferences(snapId) {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+        (0, utils_1.assert)(runtime.activeReferences > 0, 'SnapController reference management is in an invalid state.');
+        runtime.activeReferences -= 1;
+    }
+    /**
+     * Gets all snaps in their truncated format.
+     *
+     * @returns All installed snaps in their truncated format.
+     */
+    getAllSnaps() {
+        return Object.values(this.state.snaps).map(truncateSnap);
+    }
+    /**
+     * Gets the serialized permitted snaps of the given origin, if any.
+     *
+     * @param origin - The origin whose permitted snaps to retrieve.
+     * @returns The serialized permitted snaps for the origin.
+     */
+    getPermittedSnaps(origin) {
+        const permissions = this.messagingSystem.call('PermissionController:getPermissions', origin) ?? {};
+        const snaps = permissions[snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat) => caveat.type === snaps_utils_1.SnapCaveatType.SnapIds)?.value ?? {};
+        return Object.keys(snaps).reduce((permittedSnaps, snapId) => {
+            const snap = this.get(snapId);
+            const truncatedSnap = this.getTruncated(snapId);
+            if (truncatedSnap && snap?.status !== snaps_utils_1.SnapStatus.Installing) {
+                permittedSnaps[snapId] = truncatedSnap;
+            }
+            return permittedSnaps;
+        }, {});
+    }
+    /**
+     * Installs the snaps requested by the given origin, returning the snap
+     * object if the origin is permitted to install it, and an authorization error
+     * otherwise.
+     *
+     * @param origin - The origin that requested to install the snaps.
+     * @param requestedSnaps - The snaps to install.
+     * @returns An object of snap ids and snap objects, or errors if a
+     * snap couldn't be installed.
+     */
+    async installSnaps(origin, requestedSnaps) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        const result = {};
+        const snapIds = Object.keys(requestedSnaps);
+        const pendingUpdates = [];
+        const pendingInstalls = [];
+        try {
+            for (const [snapId, { version: rawVersion }] of Object.entries(requestedSnaps)) {
+                (0, snaps_utils_1.assertIsValidSnapId)(snapId);
+                const [error, version] = (0, snaps_utils_1.resolveVersionRange)(rawVersion);
+                if (error) {
+                    throw rpc_errors_1.rpcErrors.invalidParams(`The "version" field must be a valid SemVer version range if specified. Received: "${rawVersion}".`);
+                }
+                const location = __classPrivateFieldGet(this, _SnapController_detectSnapLocation, "f").call(this, snapId, {
+                    versionRange: version,
+                    fetch: __classPrivateFieldGet(this, _SnapController_fetchFunction, "f"),
+                    allowLocal: __classPrivateFieldGet(this, _SnapController_featureFlags, "f").allowLocalSnaps,
+                    resolveVersion: async (range) => __classPrivateFieldGet(this, _SnapController_featureFlags, "f").requireAllowlist
+                        ? await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_resolveAllowlistVersion).call(this, snapId, range)
+                        : range,
+                });
+                // Existing snaps may need to be updated, unless they should be re-installed (e.g. local snaps)
+                // Everything else is treated as an install
+                const isUpdate = this.has(snapId) && !location.shouldAlwaysReload;
+                if (isUpdate && __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_isValidUpdate).call(this, snapId, version)) {
+                    const existingSnap = this.getExpect(snapId);
+                    pendingUpdates.push({ snapId, oldVersion: existingSnap.version });
+                    let rollbackSnapshot = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRollbackSnapshot).call(this, snapId);
+                    if (rollbackSnapshot === undefined) {
+                        rollbackSnapshot = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createRollbackSnapshot).call(this, snapId);
+                        rollbackSnapshot.newVersion = version;
+                    }
+                    else {
+                        throw new Error('This snap is already being updated.');
+                    }
+                }
+                else if (!isUpdate) {
+                    pendingInstalls.push(snapId);
+                }
+                result[snapId] = await this.processRequestedSnap(origin, snapId, location, version);
+            }
+            // Once we finish all installs / updates, emit events.
+            pendingInstalls.forEach((snapId) => this.messagingSystem.publish(`SnapController:snapInstalled`, this.getTruncatedExpect(snapId), origin));
+            pendingUpdates.forEach(({ snapId, oldVersion }) => this.messagingSystem.publish(`SnapController:snapUpdated`, this.getTruncatedExpect(snapId), oldVersion, origin));
+            snapIds.forEach((snapId) => __classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").delete(snapId));
+        }
+        catch (error) {
+            const installed = pendingInstalls.filter((snapId) => this.has(snapId));
+            await this.removeSnaps(installed);
+            const snapshottedSnaps = [...__classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").keys()];
+            const snapsToRollback = pendingUpdates
+                .map(({ snapId }) => snapId)
+                .filter((snapId) => snapshottedSnaps.includes(snapId));
+            await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_rollbackSnaps).call(this, snapsToRollback);
+            throw error;
+        }
+        return result;
+    }
+    /**
+     * Adds, authorizes, and runs the given snap with a snap provider.
+     * Results from this method should be efficiently serializable.
+     *
+     * @param origin - The origin requesting the snap.
+     * @param snapId - The id of the snap.
+     * @param location - The location implementation of the snap.
+     * @param versionRange - The semver range of the snap to install.
+     * @returns The resulting snap object, or an error if something went wrong.
+     */
+    async processRequestedSnap(origin, snapId, location, versionRange) {
+        const existingSnap = this.getTruncated(snapId);
+        // For devX we always re-install local snaps.
+        if (existingSnap && !location.shouldAlwaysReload) {
+            if ((0, utils_1.satisfiesVersionRange)(existingSnap.version, versionRange)) {
+                return existingSnap;
+            }
+            return await this.updateSnap(origin, snapId, location, versionRange, 
+            // Since we are requesting an update from within processRequestedSnap,
+            // we disable the emitting of the snapUpdated event and rely on the caller
+            // to publish this event after the update is complete.
+            // This is necessary as installSnaps may be installing multiple snaps
+            // and we don't want to emit events prematurely.
+            false);
+        }
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanInstallSnaps).call(this);
+        let pendingApproval = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createApproval).call(this, {
+            origin,
+            snapId,
+            type: exports.SNAP_APPROVAL_INSTALL,
+        });
+        this.messagingSystem.publish('SnapController:snapInstallStarted', snapId, origin, false);
+        // Existing snaps must be stopped before overwriting
+        if (existingSnap && this.isRunning(snapId)) {
+            await this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Stop);
+        }
+        // Existing snaps that should be re-installed should not maintain their existing permissions
+        if (existingSnap && location.shouldAlwaysReload) {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_revokeAllSnapPermissions).call(this, snapId);
+        }
+        try {
+            const { sourceCode } = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_add).call(this, {
+                origin,
+                id: snapId,
+                location,
+                versionRange,
+            });
+            await this.authorize(snapId, pendingApproval);
+            pendingApproval = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createApproval).call(this, {
+                origin,
+                snapId,
+                type: exports.SNAP_APPROVAL_RESULT,
+            });
+            await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_startSnap).call(this, {
+                snapId,
+                sourceCode,
+            });
+            const truncated = this.getTruncatedExpect(snapId);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                loading: false,
+                type: exports.SNAP_APPROVAL_INSTALL,
+            });
+            return truncated;
+        }
+        catch (error) {
+            (0, snaps_utils_1.logError)(`Error when adding ${snapId}.`, error);
+            const errorString = error instanceof Error ? error.message : error.toString();
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                loading: false,
+                type: exports.SNAP_APPROVAL_INSTALL,
+                error: errorString,
+            });
+            this.messagingSystem.publish('SnapController:snapInstallFailed', snapId, origin, false, errorString);
+            throw error;
+        }
+    }
+    /**
+     * Updates an installed snap. The flow is similar to
+     * {@link SnapController.installSnaps}. The user will be asked if they want
+     * to update, then approve any permission changes, and finally the snap will
+     * be restarted.
+     *
+     * The update will fail if the user rejects any prompt or if the new version
+     * of the snap is blocked.
+     *
+     * If the original version of the snap was blocked and the update succeeded,
+     * the snap will be unblocked and enabled before it is restarted.
+     *
+     * @param origin - The origin requesting the snap update.
+     * @param snapId - The id of the Snap to be updated.
+     * @param location - The location implementation of the snap.
+     * @param newVersionRange - A semver version range in which the maximum version will be chosen.
+     * @param emitEvent - An optional boolean flag to indicate whether this update should emit an event.
+     * @returns The snap metadata if updated, `null` otherwise.
+     */
+    async updateSnap(origin, snapId, location, newVersionRange = snaps_utils_1.DEFAULT_REQUESTED_SNAP_VERSION, emitEvent = true) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanInstallSnaps).call(this);
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        if (!(0, utils_1.isValidSemVerRange)(newVersionRange)) {
+            throw new Error(`Received invalid snap version range: "${newVersionRange}".`);
+        }
+        let pendingApproval = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createApproval).call(this, {
+            origin,
+            snapId,
+            type: exports.SNAP_APPROVAL_UPDATE,
+        });
+        try {
+            this.messagingSystem.publish('SnapController:snapInstallStarted', snapId, origin, true);
+            const snap = this.getExpect(snapId);
+            const oldManifest = snap.manifest;
+            const newSnap = await (0, utils_2.fetchSnap)(snapId, location);
+            const { sourceCode: sourceCodeFile, manifest: manifestFile } = newSnap;
+            const manifest = manifestFile.result;
+            const newVersion = manifest.version;
+            if (!(0, utils_1.gtVersion)(newVersion, snap.version)) {
+                throw rpc_errors_1.rpcErrors.invalidParams(`Snap "${snapId}@${snap.version}" is already installed. Couldn't update to a version inside requested "${newVersionRange}" range.`);
+            }
+            if (!(0, utils_1.satisfiesVersionRange)(newVersion, newVersionRange)) {
+                throw new Error(`Version mismatch. Manifest for "${snapId}" specifies version "${newVersion}" which doesn't satisfy requested version range "${newVersionRange}".`);
+            }
+            await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertIsInstallAllowed).call(this, snapId, {
+                version: newVersion,
+                checksum: manifest.source.shasum,
+                permissions: manifest.initialPermissions,
+            });
+            const processedPermissions = (0, snaps_rpc_methods_1.processSnapPermissions)(manifest.initialPermissions);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_validateSnapPermissions).call(this, processedPermissions);
+            const { newPermissions, unusedPermissions, approvedPermissions } = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_calculatePermissionsChange).call(this, snapId, processedPermissions);
+            const { newConnections, unusedConnections, approvedConnections } = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_calculateConnectionsChange).call(this, snapId, oldManifest.initialConnections ?? {}, manifest.initialConnections ?? {});
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                permissions: newPermissions,
+                newVersion: manifest.version,
+                newPermissions,
+                approvedPermissions,
+                unusedPermissions,
+                newConnections,
+                unusedConnections,
+                approvedConnections,
+                loading: false,
+            });
+            const { permissions: approvedNewPermissions, ...requestData } = (await pendingApproval.promise);
+            pendingApproval = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createApproval).call(this, {
+                origin,
+                snapId,
+                type: exports.SNAP_APPROVAL_RESULT,
+            });
+            if (this.isRunning(snapId)) {
+                await this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Stop);
+            }
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_transition).call(this, snapId, snaps_utils_1.SnapStatusEvents.Update);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_set).call(this, {
+                origin,
+                id: snapId,
+                files: newSnap,
+                isUpdate: true,
+            });
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updatePermissions).call(this, {
+                snapId,
+                unusedPermissions,
+                newPermissions: approvedNewPermissions,
+                requestData,
+            });
+            if (manifest.initialConnections) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_handleInitialConnections).call(this, snapId, oldManifest.initialConnections ?? null, manifest.initialConnections);
+            }
+            const rollbackSnapshot = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRollbackSnapshot).call(this, snapId);
+            if (rollbackSnapshot !== undefined) {
+                rollbackSnapshot.permissions.revoked = unusedPermissions;
+                rollbackSnapshot.permissions.granted = approvedNewPermissions;
+                rollbackSnapshot.permissions.requestData = requestData;
+            }
+            const sourceCode = sourceCodeFile.toString();
+            (0, utils_1.assert)(typeof sourceCode === 'string' && sourceCode.length > 0, `Invalid source code for snap "${snapId}".`);
+            try {
+                await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_startSnap).call(this, { snapId, sourceCode });
+            }
+            catch {
+                throw new Error(`Snap ${snapId} crashed with updated source code.`);
+            }
+            const truncatedSnap = this.getTruncatedExpect(snapId);
+            if (emitEvent) {
+                this.messagingSystem.publish('SnapController:snapUpdated', truncatedSnap, snap.version, origin);
+            }
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                loading: false,
+                type: exports.SNAP_APPROVAL_UPDATE,
+            });
+            return truncatedSnap;
+        }
+        catch (error) {
+            (0, snaps_utils_1.logError)(`Error when updating ${snapId},`, error);
+            const errorString = error instanceof Error ? error.message : error.toString();
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                loading: false,
+                error: errorString,
+                type: exports.SNAP_APPROVAL_UPDATE,
+            });
+            this.messagingSystem.publish('SnapController:snapInstallFailed', snapId, origin, true, errorString);
+            throw error;
+        }
+    }
+    /**
+     * Get metadata for the given snap ID.
+     *
+     * @param snapId - The ID of the snap to get metadata for.
+     * @returns The metadata for the given snap ID, or `null` if the snap is not
+     * verified.
+     */
+    async getRegistryMetadata(snapId) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        return await this.messagingSystem.call('SnapsRegistry:getMetadata', snapId);
+    }
+    /**
+     * Initiates a request for the given snap's initial permissions.
+     * Must be called in order. See processRequestedSnap.
+     *
+     * This function is not hash private yet because of tests.
+     *
+     * @param snapId - The id of the Snap.
+     * @param pendingApproval - Pending approval to update.
+     * @returns The snap's approvedPermissions.
+     */
+    async authorize(snapId, pendingApproval) {
+        (0, logging_1.log)(`Authorizing snap: ${snapId}`);
+        const snapsState = this.state.snaps;
+        const snap = snapsState[snapId];
+        const { initialPermissions, initialConnections } = snap;
+        try {
+            const processedPermissions = (0, snaps_rpc_methods_1.processSnapPermissions)(initialPermissions);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_validateSnapPermissions).call(this, processedPermissions);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updateApproval).call(this, pendingApproval.id, {
+                loading: false,
+                connections: initialConnections ?? {},
+                permissions: processedPermissions,
+            });
+            const { permissions: approvedPermissions, ...requestData } = (await pendingApproval.promise);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updatePermissions).call(this, {
+                snapId,
+                newPermissions: approvedPermissions,
+                requestData,
+            });
+            if (snap.manifest.initialConnections) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_handleInitialConnections).call(this, snapId, null, snap.manifest.initialConnections);
+            }
+        }
+        finally {
+            const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+            runtime.installPromise = null;
+        }
+    }
+    destroy() {
+        super.destroy();
+        if (__classPrivateFieldGet(this, _SnapController_timeoutForLastRequestStatus, "f")) {
+            clearTimeout(__classPrivateFieldGet(this, _SnapController_timeoutForLastRequestStatus, "f"));
+        }
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.messagingSystem.unsubscribe('ExecutionService:unhandledError', this._onUnhandledSnapError);
+        this.messagingSystem.unsubscribe('ExecutionService:outboundRequest', this._onOutboundRequest);
+        this.messagingSystem.unsubscribe('ExecutionService:outboundResponse', this._onOutboundResponse);
+        this.messagingSystem.clearEventSubscriptions('SnapController:snapInstalled');
+        this.messagingSystem.clearEventSubscriptions('SnapController:snapUpdated');
+        /* eslint-enable @typescript-eslint/unbound-method */
+    }
+    /**
+     * Passes a JSON-RPC request object to the RPC handler function of a snap.
+     *
+     * @param options - A bag of options.
+     * @param options.snapId - The ID of the recipient snap.
+     * @param options.origin - The origin of the RPC request.
+     * @param options.handler - The handler to trigger on the snap for the request.
+     * @param options.request - The JSON-RPC request object.
+     * @returns The result of the JSON-RPC request.
+     */
+    async handleRequest({ snapId, origin, handler: handlerType, request: rawRequest, }) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertCanUsePlatform).call(this);
+        const request = {
+            jsonrpc: '2.0',
+            id: (0, nanoid_1.nanoid)(),
+            ...rawRequest,
+        };
+        (0, utils_1.assertIsJsonRpcRequest)(request);
+        const permissionName = snaps_rpc_methods_1.handlerEndowments[handlerType];
+        (0, utils_1.assert)(typeof permissionName === 'string' || permissionName === null, "'permissionName' must be either a string or null.");
+        const permissions = this.messagingSystem.call('PermissionController:getPermissions', snapId);
+        // If permissionName is null, the handler does not require a permission.
+        if (permissionName !== null &&
+            (!permissions || !(0, utils_1.hasProperty)(permissions, permissionName))) {
+            throw new Error(`Snap "${snapId}" is not permitted to use "${permissionName}".`);
+        }
+        const handlerPermissions = permissionName
+            ? permissions[permissionName]
+            : undefined;
+        if (permissionName === snaps_rpc_methods_1.SnapEndowments.Rpc ||
+            permissionName === snaps_rpc_methods_1.SnapEndowments.Keyring) {
+            (0, utils_1.assert)(handlerPermissions);
+            const subject = this.messagingSystem.call('SubjectMetadataController:getSubjectMetadata', origin);
+            const origins = permissionName === snaps_rpc_methods_1.SnapEndowments.Rpc
+                ? (0, snaps_rpc_methods_1.getRpcCaveatOrigins)(handlerPermissions)
+                : (0, snaps_rpc_methods_1.getKeyringCaveatOrigins)(handlerPermissions);
+            (0, utils_1.assert)(origins);
+            if (!(0, snaps_utils_1.isOriginAllowed)(origins, subject?.subjectType ?? permission_controller_1.SubjectType.Website, origin)) {
+                throw new Error(`Snap "${snapId}" is not permitted to handle requests from "${origin}".`);
+            }
+        }
+        const handler = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRpcRequestHandler).call(this, snapId);
+        if (!handler) {
+            throw new Error(`Snap RPC message handler not found for snap "${snapId}".`);
+        }
+        const timeout = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getExecutionTimeout).call(this, handlerPermissions);
+        return handler({ origin, handler: handlerType, request, timeout });
+    }
+}
+exports.SnapController = SnapController;
+_SnapController_closeAllConnections = new WeakMap(), _SnapController_dynamicPermissions = new WeakMap(), _SnapController_environmentEndowmentPermissions = new WeakMap(), _SnapController_excludedPermissions = new WeakMap(), _SnapController_featureFlags = new WeakMap(), _SnapController_fetchFunction = new WeakMap(), _SnapController_idleTimeCheckInterval = new WeakMap(), _SnapController_maxIdleTime = new WeakMap(), _SnapController_encryptor = new WeakMap(), _SnapController_getMnemonic = new WeakMap(), _SnapController_getFeatureFlags = new WeakMap(), _SnapController_detectSnapLocation = new WeakMap(), _SnapController_snapsRuntimeData = new WeakMap(), _SnapController_rollbackSnapshots = new WeakMap(), _SnapController_timeoutForLastRequestStatus = new WeakMap(), _SnapController_statusMachine = new WeakMap(), _SnapController_preinstalledSnaps = new WeakMap(), _SnapController_instances = new WeakSet(), _SnapController_initializeStateMachine = function _SnapController_initializeStateMachine() {
+    const disableGuard = ({ snapId }) => {
+        return this.getExpect(snapId).enabled;
+    };
+    const statusConfig = {
+        initial: snaps_utils_1.SnapStatus.Installing,
+        states: {
+            [snaps_utils_1.SnapStatus.Installing]: {
+                on: {
+                    [snaps_utils_1.SnapStatusEvents.Start]: {
+                        target: snaps_utils_1.SnapStatus.Running,
+                        cond: disableGuard,
+                    },
+                },
+            },
+            [snaps_utils_1.SnapStatus.Updating]: {
+                on: {
+                    [snaps_utils_1.SnapStatusEvents.Start]: {
+                        target: snaps_utils_1.SnapStatus.Running,
+                        cond: disableGuard,
+                    },
+                    [snaps_utils_1.SnapStatusEvents.Stop]: snaps_utils_1.SnapStatus.Stopped,
+                },
+            },
+            [snaps_utils_1.SnapStatus.Running]: {
+                on: {
+                    [snaps_utils_1.SnapStatusEvents.Stop]: snaps_utils_1.SnapStatus.Stopped,
+                    [snaps_utils_1.SnapStatusEvents.Crash]: snaps_utils_1.SnapStatus.Crashed,
+                },
+            },
+            [snaps_utils_1.SnapStatus.Stopped]: {
+                on: {
+                    [snaps_utils_1.SnapStatusEvents.Start]: {
+                        target: snaps_utils_1.SnapStatus.Running,
+                        cond: disableGuard,
+                    },
+                    [snaps_utils_1.SnapStatusEvents.Update]: snaps_utils_1.SnapStatus.Updating,
+                },
+            },
+            [snaps_utils_1.SnapStatus.Crashed]: {
+                on: {
+                    [snaps_utils_1.SnapStatusEvents.Start]: {
+                        target: snaps_utils_1.SnapStatus.Running,
+                        cond: disableGuard,
+                    },
+                    [snaps_utils_1.SnapStatusEvents.Update]: snaps_utils_1.SnapStatus.Updating,
+                },
+            },
+        },
+    };
+    __classPrivateFieldSet(this, _SnapController_statusMachine, (0, fsm_1.createMachine)(statusConfig), "f");
+    (0, fsm_2.validateMachine)(__classPrivateFieldGet(this, _SnapController_statusMachine, "f"));
+}, _SnapController_registerMessageHandlers = function _SnapController_registerMessageHandlers() {
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:clearSnapState`, (...args) => this.clearSnapState(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:get`, (...args) => this.get(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:getSnapState`, async (...args) => this.getSnapState(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:handleRequest`, async (...args) => this.handleRequest(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:has`, (...args) => this.has(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:updateBlockedSnaps`, async () => this.updateBlockedSnaps());
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:updateSnapState`, async (...args) => this.updateSnapState(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:enable`, (...args) => this.enableSnap(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:disable`, async (...args) => this.disableSnap(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:remove`, async (...args) => this.removeSnap(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:getPermitted`, (...args) => this.getPermittedSnaps(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:install`, async (...args) => this.installSnaps(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:getAll`, (...args) => this.getAllSnaps(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:incrementActiveReferences`, (...args) => this.incrementActiveReferences(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:decrementActiveReferences`, (...args) => this.decrementActiveReferences(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:getRegistryMetadata`, async (...args) => this.getRegistryMetadata(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:disconnectOrigin`, (...args) => this.removeSnapFromSubject(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:revokeDynamicPermissions`, (...args) => this.revokeDynamicSnapPermissions(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:getFile`, async (...args) => this.getSnapFile(...args));
+    this.messagingSystem.registerActionHandler(`${exports.controllerName}:stopAllSnaps`, async (...args) => this.stopAllSnaps(...args));
+}, _SnapController_handlePreinstalledSnaps = function _SnapController_handlePreinstalledSnaps(preinstalledSnaps) {
+    for (const { snapId, manifest, files, removable, hidden, } of preinstalledSnaps) {
+        const existingSnap = this.get(snapId);
+        const isAlreadyInstalled = existingSnap !== undefined;
+        const isUpdate = isAlreadyInstalled && (0, utils_1.gtVersion)(manifest.version, existingSnap.version);
+        // Disallow downgrades and overwriting non preinstalled snaps
+        if (isAlreadyInstalled &&
+            (!isUpdate || existingSnap.preinstalled !== true)) {
+            continue;
+        }
+        const manifestFile = new snaps_utils_1.VirtualFile({
+            path: snaps_utils_1.NpmSnapFileNames.Manifest,
+            value: JSON.stringify(manifest),
+            result: manifest,
+        });
+        const virtualFiles = files.map(({ path, value }) => new snaps_utils_1.VirtualFile({ value, path }));
+        const { filePath, iconPath } = manifest.source.location.npm;
+        const sourceCode = virtualFiles.find((file) => file.path === filePath);
+        const svgIcon = iconPath
+            ? virtualFiles.find((file) => file.path === iconPath)
+            : undefined;
+        (0, utils_1.assert)(sourceCode, 'Source code not provided for preinstalled snap.');
+        (0, utils_1.assert)(!iconPath || (iconPath && svgIcon), 'Icon not provided for preinstalled snap.');
+        (0, utils_1.assert)(manifest.source.files === undefined, 'Auxiliary files are not currently supported for preinstalled snaps.');
+        const localizationFiles = manifest.source.locales?.map((path) => virtualFiles.find((file) => file.path === path)) ?? [];
+        const validatedLocalizationFiles = (0, snaps_utils_1.getValidatedLocalizationFiles)(localizationFiles.filter(Boolean));
+        (0, utils_1.assert)(localizationFiles.length === validatedLocalizationFiles.length, 'Missing localization files for preinstalled snap.');
+        const filesObject = {
+            manifest: manifestFile,
+            sourceCode,
+            svgIcon,
+            auxiliaryFiles: [],
+            localizationFiles: validatedLocalizationFiles,
+        };
+        // Add snap to the SnapController state
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_set).call(this, {
+            id: snapId,
+            origin: 'metamask',
+            files: filesObject,
+            removable,
+            hidden,
+            preinstalled: true,
+        });
+        // Setup permissions
+        const processedPermissions = (0, snaps_rpc_methods_1.processSnapPermissions)(manifest.initialPermissions);
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_validateSnapPermissions).call(this, processedPermissions);
+        const { newPermissions, unusedPermissions } = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_calculatePermissionsChange).call(this, snapId, processedPermissions);
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updatePermissions).call(this, { snapId, newPermissions, unusedPermissions });
+        if (manifest.initialConnections) {
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_handleInitialConnections).call(this, snapId, existingSnap?.initialConnections ?? null, manifest.initialConnections);
+        }
+        // Set status
+        this.update((state) => {
+            state.snaps[snapId].status = snaps_utils_1.SnapStatus.Stopped;
+        });
+    }
+}, _SnapController_pollForLastRequestStatus = function _SnapController_pollForLastRequestStatus() {
+    __classPrivateFieldSet(this, _SnapController_timeoutForLastRequestStatus, setTimeout(() => {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_stopSnapsLastRequestPastMax).call(this).catch((error) => {
+            // TODO: Decide how to handle errors.
+            (0, snaps_utils_1.logError)(error);
+        });
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_pollForLastRequestStatus).call(this);
+    }, __classPrivateFieldGet(this, _SnapController_idleTimeCheckInterval, "f")), "f");
+}, _SnapController_blockSnap = 
+/**
+ * Blocks an installed snap and prevents it from being started again. Emits
+ * {@link SnapBlocked}. Does nothing if the snap is not installed.
+ *
+ * @param snapId - The snap to block.
+ * @param blockedSnapInfo - Information detailing why the snap is blocked.
+ */
+async function _SnapController_blockSnap(snapId, blockedSnapInfo) {
+    if (!this.has(snapId)) {
+        return;
+    }
+    try {
+        this.update((state) => {
+            state.snaps[snapId].blocked = true;
+            state.snaps[snapId].blockInformation = blockedSnapInfo;
+        });
+        await this.disableSnap(snapId);
+    }
+    catch (error) {
+        (0, snaps_utils_1.logError)(`Encountered error when stopping blocked snap "${snapId}".`, error);
+    }
+    this.messagingSystem.publish(`${exports.controllerName}:snapBlocked`, snapId, blockedSnapInfo);
+}, _SnapController_unblockSnap = function _SnapController_unblockSnap(snapId) {
+    if (!this.has(snapId) || !this.state.snaps[snapId].blocked) {
+        return;
+    }
+    this.update((state) => {
+        state.snaps[snapId].blocked = false;
+        delete state.snaps[snapId].blockInformation;
+    });
+    this.messagingSystem.publish(`${exports.controllerName}:snapUnblocked`, snapId);
+}, _SnapController_assertIsInstallAllowed = async function _SnapController_assertIsInstallAllowed(snapId, snapInfo) {
+    const results = await this.messagingSystem.call('SnapsRegistry:get', {
+        [snapId]: snapInfo,
+    });
+    const result = results[snapId];
+    if (result.status === registry_1.SnapsRegistryStatus.Blocked) {
+        throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": The version is blocked. ${result.reason?.explanation ?? ''}`);
+    }
+    const isAllowlistingRequired = Object.keys(snapInfo.permissions).some((permission) => !constants_1.ALLOWED_PERMISSIONS.includes(permission));
+    if (__classPrivateFieldGet(this, _SnapController_featureFlags, "f").requireAllowlist &&
+        isAllowlistingRequired &&
+        result.status !== registry_1.SnapsRegistryStatus.Verified) {
+        throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": ${result.status === registry_1.SnapsRegistryStatus.Unavailable
+            ? 'The registry is temporarily unavailable.'
+            : 'The snap is not on the allowlist.'}`);
+    }
+}, _SnapController_assertCanInstallSnaps = function _SnapController_assertCanInstallSnaps() {
+    (0, utils_1.assert)(__classPrivateFieldGet(this, _SnapController_featureFlags, "f").disableSnapInstallation !== true, 'Installing Snaps is currently disabled in this version of MetaMask.');
+}, _SnapController_assertCanUsePlatform = function _SnapController_assertCanUsePlatform() {
+    const flags = __classPrivateFieldGet(this, _SnapController_getFeatureFlags, "f").call(this);
+    (0, utils_1.assert)(flags.disableSnaps !== true, 'The Snaps platform requires basic functionality to be used. Enable basic functionality in the settings to use the Snaps platform.');
+}, _SnapController_stopSnapsLastRequestPastMax = async function _SnapController_stopSnapsLastRequestPastMax() {
+    const entries = [...__classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").entries()];
+    return Promise.all(entries
+        .filter(([_snapId, runtime]) => runtime.activeReferences === 0 &&
+        runtime.pendingInboundRequests.length === 0 &&
+        runtime.lastRequest &&
+        __classPrivateFieldGet(this, _SnapController_maxIdleTime, "f") &&
+        (0, utils_1.timeSince)(runtime.lastRequest) > __classPrivateFieldGet(this, _SnapController_maxIdleTime, "f"))
+        .map(async ([snapId]) => this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Stop)));
+}, _SnapController_transition = function _SnapController_transition(snapId, event) {
+    const { interpreter } = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    interpreter.send(event);
+    this.update((state) => {
+        state.snaps[snapId].status = interpreter.state.value;
+    });
+}, _SnapController_terminateSnap = 
+/**
+ * Terminates the specified snap and emits the `snapTerminated` event.
+ *
+ * @param snapId - The snap to terminate.
+ */
+async function _SnapController_terminateSnap(snapId) {
+    await this.messagingSystem.call('ExecutionService:terminateSnap', snapId);
+    // Hack to give up execution for a bit to let gracefully terminating Snaps return.
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    // Unresponsive requests may still be timed, time them out.
+    runtime.pendingInboundRequests
+        .filter((pendingRequest) => pendingRequest.timer.status !== 'finished')
+        .forEach((pendingRequest) => pendingRequest.timer.finish());
+    // Hack to give up execution for a bit to let timed out requests return.
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    this.messagingSystem.publish('SnapController:snapTerminated', this.getTruncatedExpect(snapId));
+}, _SnapController_getSnapEncryptionKey = 
+/**
+ * Generate an encryption key to be used for state encryption for a given Snap.
+ *
+ * @param options - An options bag.
+ * @param options.snapId - The Snap ID.
+ * @param options.salt - A salt to be used for the encryption key.
+ * @param options.useCache - Whether to use caching or not.
+ * @param options.keyMetadata - Optional metadata about how to derive the encryption key.
+ * @returns An encryption key.
+ */
+async function _SnapController_getSnapEncryptionKey({ snapId, salt: passedSalt, useCache, keyMetadata, }) {
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    if (runtime.encryptionKey && runtime.encryptionSalt && useCache) {
+        return {
+            key: await __classPrivateFieldGet(this, _SnapController_encryptor, "f").importKey(runtime.encryptionKey),
+            salt: runtime.encryptionSalt,
+        };
+    }
+    const salt = passedSalt ?? __classPrivateFieldGet(this, _SnapController_encryptor, "f").generateSalt();
+    const mnemonicPhrase = await __classPrivateFieldGet(this, _SnapController_getMnemonic, "f").call(this);
+    const entropy = await (0, snaps_rpc_methods_1.getEncryptionEntropy)({ snapId, mnemonicPhrase });
+    const encryptionKey = await __classPrivateFieldGet(this, _SnapController_encryptor, "f").keyFromPassword(entropy, salt, true, keyMetadata);
+    const exportedKey = await __classPrivateFieldGet(this, _SnapController_encryptor, "f").exportKey(encryptionKey);
+    // Cache exported encryption key in runtime
+    if (useCache) {
+        runtime.encryptionKey = exportedKey;
+        runtime.encryptionSalt = salt;
+    }
+    return { key: encryptionKey, salt };
+}, _SnapController_decryptSnapState = 
+/**
+ * Decrypt the encrypted state for a given Snap.
+ *
+ * @param snapId - The Snap ID.
+ * @param state - The encrypted state as a string.
+ * @returns A valid JSON object derived from the encrypted state.
+ * @throws If the decryption fails or the decrypted state is not valid JSON.
+ */
+async function _SnapController_decryptSnapState(snapId, state) {
+    try {
+        const parsed = (0, snaps_utils_1.parseJson)(state);
+        const { salt, keyMetadata } = parsed;
+        const useCache = __classPrivateFieldGet(this, _SnapController_encryptor, "f").isVaultUpdated(state);
+        const { key } = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getSnapEncryptionKey).call(this, {
+            snapId,
+            salt,
+            useCache,
+            // When decrypting state we expect key metadata to be present.
+            // If it isn't present, we assume that the Snap state we are decrypting is old enough to use the legacy encryption params.
+            keyMetadata: keyMetadata ?? constants_1.LEGACY_ENCRYPTION_KEY_DERIVATION_OPTIONS,
+        });
+        const decryptedState = await __classPrivateFieldGet(this, _SnapController_encryptor, "f").decryptWithKey(key, parsed);
+        (0, utils_1.assert)((0, utils_1.isValidJson)(decryptedState));
+        return decryptedState;
+    }
+    catch {
+        throw rpc_errors_1.rpcErrors.internal({
+            message: 'Failed to decrypt snap state, the state must be corrupted.',
+        });
+    }
+}, _SnapController_encryptSnapState = 
+/**
+ * Encrypt a JSON state object for a given Snap.
+ *
+ * Note: This function does not assert the validity of the object,
+ * please ensure only valid JSON is passed to it.
+ *
+ * @param snapId - The Snap ID.
+ * @param state - The state object.
+ * @returns A string containing the encrypted JSON object.
+ */
+async function _SnapController_encryptSnapState(snapId, state) {
+    const { key, salt } = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getSnapEncryptionKey).call(this, {
+        snapId,
+        useCache: true,
+    });
+    const encryptedState = await __classPrivateFieldGet(this, _SnapController_encryptor, "f").encryptWithKey(key, state);
+    encryptedState.salt = salt;
+    return JSON.stringify(encryptedState);
+}, _SnapController_handleInitialConnections = function _SnapController_handleInitialConnections(snapId, previousInitialConnections, initialConnections) {
+    if (previousInitialConnections) {
+        const revokedInitialConnections = (0, utils_2.setDiff)(previousInitialConnections, initialConnections);
+        for (const origin of Object.keys(revokedInitialConnections)) {
+            this.removeSnapFromSubject(origin, snapId);
+        }
+    }
+    for (const origin of Object.keys(initialConnections)) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_addSnapToSubject).call(this, origin, snapId);
+    }
+}, _SnapController_addSnapToSubject = function _SnapController_addSnapToSubject(origin, snapId) {
+    const subjectPermissions = this.messagingSystem.call('PermissionController:getPermissions', origin);
+    const existingCaveat = subjectPermissions?.[snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat) => caveat.type === snaps_utils_1.SnapCaveatType.SnapIds);
+    const subjectHasSnap = Boolean(existingCaveat?.value?.[snapId]);
+    // If the subject is already connected to the snap, this is a no-op.
+    if (subjectHasSnap) {
+        return;
+    }
+    // If an existing caveat exists, we add the snap to that.
+    if (existingCaveat) {
+        this.messagingSystem.call('PermissionController:updateCaveat', origin, snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY, snaps_utils_1.SnapCaveatType.SnapIds, { ...existingCaveat.value, [snapId]: {} });
+        return;
+    }
+    const approvedPermissions = {
+        [snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY]: {
+            caveats: [
+                {
+                    type: snaps_utils_1.SnapCaveatType.SnapIds,
+                    value: {
+                        [snapId]: {},
+                    },
+                },
+            ],
+        },
+    };
+    this.messagingSystem.call('PermissionController:grantPermissions', {
+        approvedPermissions,
+        subject: { origin },
+    });
+}, _SnapController_removeSnapFromSubjects = function _SnapController_removeSnapFromSubjects(snapId) {
+    const subjects = this.messagingSystem.call('PermissionController:getSubjectNames');
+    for (const subject of subjects) {
+        this.removeSnapFromSubject(subject, snapId);
+    }
+}, _SnapController_revokeAllSnapPermissions = function _SnapController_revokeAllSnapPermissions(snapId) {
+    if (this.messagingSystem.call('PermissionController:hasPermissions', snapId)) {
+        this.messagingSystem.call('PermissionController:revokeAllPermissions', snapId);
+    }
+}, _SnapController_createApproval = function _SnapController_createApproval({ origin, snapId, type, }) {
+    const id = (0, nanoid_1.nanoid)();
+    const promise = this.messagingSystem.call('ApprovalController:addRequest', {
+        origin,
+        id,
+        type,
+        requestData: {
+            // Mirror previous installation metadata
+            metadata: { id, origin: snapId, dappOrigin: origin },
+            snapId,
+        },
+        requestState: {
+            loading: true,
+        },
+    }, true);
+    return { id, promise };
+}, _SnapController_updateApproval = function _SnapController_updateApproval(id, requestState) {
+    try {
+        this.messagingSystem.call('ApprovalController:updateRequestState', {
+            id,
+            requestState,
+        });
+    }
+    catch {
+        // Do nothing
+    }
+}, _SnapController_resolveAllowlistVersion = async function _SnapController_resolveAllowlistVersion(snapId, versionRange) {
+    return await this.messagingSystem.call('SnapsRegistry:resolveVersion', snapId, versionRange);
+}, _SnapController_add = 
+/**
+ * Returns a promise representing the complete installation of the requested snap.
+ * If the snap is already being installed, the previously pending promise will be returned.
+ *
+ * @param args - Object containing the snap id and either the URL of the snap's manifest,
+ * or the snap's manifest and source code. The object may also optionally contain a target
+ * version.
+ * @returns The resulting snap object.
+ */
+async function _SnapController_add(args) {
+    const { id: snapId, location, versionRange } = args;
+    __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_setupRuntime).call(this, snapId);
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    if (!runtime.installPromise) {
+        (0, logging_1.log)(`Adding snap: ${snapId}`);
+        // If fetching and setting the snap succeeds, this property will be set
+        // to null in the authorize() method.
+        runtime.installPromise = (async () => {
+            const fetchedSnap = await (0, utils_2.fetchSnap)(snapId, location);
+            const manifest = fetchedSnap.manifest.result;
+            if (!(0, utils_1.satisfiesVersionRange)(manifest.version, versionRange)) {
+                throw new Error(`Version mismatch. Manifest for "${snapId}" specifies version "${manifest.version}" which doesn't satisfy requested version range "${versionRange}".`);
+            }
+            await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertIsInstallAllowed).call(this, snapId, {
+                version: manifest.version,
+                checksum: manifest.source.shasum,
+                permissions: manifest.initialPermissions,
+            });
+            return __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_set).call(this, {
+                ...args,
+                files: fetchedSnap,
+                id: snapId,
+            });
+        })();
+    }
+    try {
+        return await runtime.installPromise;
+    }
+    catch (error) {
+        // Reset promise so users can retry installation in case the problem is
+        // temporary.
+        runtime.installPromise = null;
+        throw error;
+    }
+}, _SnapController_startSnap = async function _SnapController_startSnap(snapData) {
+    const { snapId } = snapData;
+    if (this.isRunning(snapId)) {
+        throw new Error(`Snap "${snapId}" is already started.`);
+    }
+    try {
+        const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+        const result = await this.messagingSystem.call('ExecutionService:executeSnap', {
+            ...snapData,
+            endowments: await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getEndowments).call(this, snapId),
+        });
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_transition).call(this, snapId, snaps_utils_1.SnapStatusEvents.Start);
+        // We treat the initialization of the snap as the first request, for idle timing purposes.
+        runtime.lastRequest = Date.now();
+        return result;
+    }
+    catch (error) {
+        await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_terminateSnap).call(this, snapId);
+        throw error;
+    }
+}, _SnapController_getEndowments = 
+/**
+ * Gets the names of all endowments that will be added to the Snap's
+ * Compartment when it executes. These should be the names of global
+ * JavaScript APIs accessible in the root realm of the execution environment.
+ *
+ * Throws an error if the endowment getter for a permission returns a truthy
+ * value that is not an array of strings.
+ *
+ * @param snapId - The id of the snap whose SES endowments to get.
+ * @returns An array of the names of the endowments.
+ */
+async function _SnapController_getEndowments(snapId) {
+    let allEndowments = [];
+    for (const permissionName of __classPrivateFieldGet(this, _SnapController_environmentEndowmentPermissions, "f")) {
+        if (this.messagingSystem.call('PermissionController:hasPermission', snapId, permissionName)) {
+            const endowments = await this.messagingSystem.call('PermissionController:getEndowments', snapId, permissionName);
+            if (endowments) {
+                // We don't have any guarantees about the type of the endowments
+                // value, so we have to guard at runtime.
+                if (!Array.isArray(endowments) ||
+                    endowments.some((value) => typeof value !== 'string')) {
+                    throw new Error('Expected an array of string endowment names.');
+                }
+                allEndowments = allEndowments.concat(endowments);
+            }
+        }
+    }
+    const dedupedEndowments = [
+        ...new Set([...snaps_utils_1.DEFAULT_ENDOWMENTS, ...allEndowments]),
+    ];
+    if (dedupedEndowments.length <
+        // This is a bug in TypeScript: https://github.com/microsoft/TypeScript/issues/48313
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        snaps_utils_1.DEFAULT_ENDOWMENTS.length + allEndowments.length) {
+        (0, snaps_utils_1.logError)(`Duplicate endowments found for ${snapId}. Default endowments should not be requested.`, allEndowments);
+    }
+    return dedupedEndowments;
+}, _SnapController_set = function _SnapController_set(args) {
+    const { id: snapId, origin, files, isUpdate = false, removable, preinstalled, hidden, } = args;
+    const { manifest, sourceCode: sourceCodeFile, svgIcon, auxiliaryFiles: rawAuxiliaryFiles, localizationFiles, } = files;
+    (0, snaps_utils_1.assertIsSnapManifest)(manifest.result);
+    const { version } = manifest.result;
+    const sourceCode = sourceCodeFile.toString();
+    (0, utils_1.assert)(typeof sourceCode === 'string' && sourceCode.length > 0, `Invalid source code for snap "${snapId}".`);
+    const auxiliaryFiles = rawAuxiliaryFiles.map((file) => {
+        (0, utils_1.assert)(typeof file.data.base64 === 'string');
+        return {
+            path: file.path,
+            value: file.data.base64,
+        };
+    });
+    const snapsState = this.state.snaps;
+    const existingSnap = snapsState[snapId];
+    const previousVersionHistory = existingSnap?.versionHistory ?? [];
+    const versionHistory = [
+        ...previousVersionHistory,
+        {
+            version,
+            date: Date.now(),
+            origin,
+        },
+    ];
+    const localizedFiles = localizationFiles.map((file) => file.result);
+    const snap = {
+        // Restore relevant snap state if it exists
+        ...existingSnap,
+        // Note that the snap will be unblocked and enabled, regardless of its
+        // previous state.
+        blocked: false,
+        enabled: true,
+        removable,
+        preinstalled,
+        hidden,
+        id: snapId,
+        initialConnections: manifest.result.initialConnections,
+        initialPermissions: manifest.result.initialPermissions,
+        manifest: manifest.result,
+        status: __classPrivateFieldGet(this, _SnapController_statusMachine, "f").config.initial,
+        sourceCode,
+        version,
+        versionHistory,
+        auxiliaryFiles,
+        localizationFiles: localizedFiles,
+    };
+    // If the snap was blocked, it isn't any longer
+    delete snap.blockInformation;
+    // store the snap back in state
+    const { inversePatches } = this.update((state) => {
+        state.snaps[snapId] = snap;
+    });
+    // checking for isUpdate here as this function is also used in
+    // the install flow, we do not care to create snapshots for installs
+    if (isUpdate) {
+        const rollbackSnapshot = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRollbackSnapshot).call(this, snapId);
+        if (rollbackSnapshot !== undefined) {
+            rollbackSnapshot.statePatches = inversePatches;
+        }
+    }
+    // In case the Snap uses a localized manifest, we need to get the
+    // proposed name from the localized manifest.
+    const { proposedName } = (0, snaps_utils_1.getLocalizedSnapManifest)(manifest.result, 'en', localizedFiles);
+    this.messagingSystem.call('SubjectMetadataController:addSubjectMetadata', {
+        subjectType: permission_controller_1.SubjectType.Snap,
+        name: proposedName,
+        origin: snap.id,
+        version,
+        svgIcon: svgIcon?.toString() ?? null,
+    });
+    return { ...snap, sourceCode };
+}, _SnapController_validateSnapPermissions = function _SnapController_validateSnapPermissions(processedPermissions) {
+    const permissionKeys = Object.keys(processedPermissions);
+    const handlerPermissions = Array.from(new Set(Object.values(snaps_rpc_methods_1.handlerEndowments)));
+    (0, utils_1.assert)(permissionKeys.some((key) => handlerPermissions.includes(key)), `A snap must request at least one of the following permissions: ${handlerPermissions
+        .filter((handler) => handler !== null)
+        .join(', ')}.`);
+    const excludedPermissionErrors = permissionKeys.reduce((errors, permission) => {
+        if ((0, utils_1.hasProperty)(__classPrivateFieldGet(this, _SnapController_excludedPermissions, "f"), permission)) {
+            errors.push(__classPrivateFieldGet(this, _SnapController_excludedPermissions, "f")[permission]);
+        }
+        return errors;
+    }, []);
+    (0, utils_1.assert)(excludedPermissionErrors.length === 0, `One or more permissions are not allowed:\n${excludedPermissionErrors.join('\n')}`);
+}, _SnapController_getExecutionTimeout = function _SnapController_getExecutionTimeout(permission) {
+    return (0, snaps_rpc_methods_1.getMaxRequestTimeCaveat)(permission) ?? this.maxRequestTime;
+}, _SnapController_getRpcRequestHandler = function _SnapController_getRpcRequestHandler(snapId) {
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    const existingHandler = runtime.rpcHandler;
+    if (existingHandler) {
+        return existingHandler;
+    }
+    const requestQueue = new RequestQueue_1.RequestQueue(5);
+    // We need to set up this promise map to map snapIds to their respective startPromises,
+    // because otherwise we would lose context on the correct startPromise.
+    const startPromises = new Map();
+    const rpcHandler = async ({ origin, handler: handlerType, request, timeout, }) => {
+        if (this.state.snaps[snapId].enabled === false) {
+            throw new Error(`Snap "${snapId}" is disabled.`);
+        }
+        if (this.state.snaps[snapId].status === snaps_utils_1.SnapStatus.Installing) {
+            throw new Error(`Snap "${snapId}" is currently being installed. Please try again later.`);
+        }
+        if (!this.isRunning(snapId)) {
+            let localStartPromise = startPromises.get(snapId);
+            if (!localStartPromise) {
+                localStartPromise = this.startSnap(snapId);
+                startPromises.set(snapId, localStartPromise);
+            }
+            else if (requestQueue.get(origin) >= requestQueue.maxQueueSize) {
+                throw new Error('Exceeds maximum number of requests waiting to be resolved, please try again.');
+            }
+            requestQueue.increment(origin);
+            try {
+                await localStartPromise;
+            }
+            finally {
+                requestQueue.decrement(origin);
+                // Only delete startPromise for a snap if its value hasn't changed
+                if (startPromises.get(snapId) === localStartPromise) {
+                    startPromises.delete(snapId);
+                }
+            }
+        }
+        const timer = new Timer_1.Timer(timeout);
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_recordSnapRpcRequestStart).call(this, snapId, request.id, timer);
+        const handleRpcRequestPromise = this.messagingSystem.call('ExecutionService:handleRpcRequest', snapId, { origin, handler: handlerType, request });
+        // This will either get the result or reject due to the timeout.
+        try {
+            const result = await (0, utils_2.withTimeout)(handleRpcRequestPromise, timer);
+            if (result === utils_2.hasTimedOut) {
+                throw new Error(`${snapId} failed to respond to the request in time.`);
+            }
+            await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertSnapRpcRequestResult).call(this, snapId, handlerType, result);
+            const transformedResult = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_transformSnapRpcRequestResult).call(this, snapId, handlerType, result);
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_recordSnapRpcRequestFinish).call(this, snapId, request.id);
+            return transformedResult;
+        }
+        catch (error) {
+            // We flag the RPC request as finished early since termination may affect pending requests
+            __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_recordSnapRpcRequestFinish).call(this, snapId, request.id);
+            const [jsonRpcError, handled] = (0, snaps_utils_1.unwrapError)(error);
+            if (!handled) {
+                await this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Crash);
+            }
+            throw jsonRpcError;
+        }
+    };
+    runtime.rpcHandler = rpcHandler;
+    return rpcHandler;
+}, _SnapController_createInterface = 
+/**
+ * Create a dynamic interface in the SnapInterfaceController.
+ *
+ * @param snapId - The snap ID.
+ * @param content - The initial interface content.
+ * @returns An identifier that can be used to identify the interface.
+ */
+async function _SnapController_createInterface(snapId, content) {
+    return this.messagingSystem.call('SnapInterfaceController:createInterface', snapId, content);
+}, _SnapController_assertInterfaceExists = function _SnapController_assertInterfaceExists(snapId, id) {
+    // This will throw if the interface isn't accessible, but we assert nevertheless.
+    (0, utils_1.assert)(this.messagingSystem.call('SnapInterfaceController:getInterface', snapId, id));
+}, _SnapController_transformSnapRpcRequestResult = 
+/**
+ * Transform a RPC request result if necessary.
+ *
+ * @param snapId - The snap ID of the snap that produced the result.
+ * @param handlerType - The handler type that produced the result.
+ * @param result - The result.
+ * @returns The transformed result if applicable, otherwise the original result.
+ */
+async function _SnapController_transformSnapRpcRequestResult(snapId, handlerType, result) {
+    switch (handlerType) {
+        case snaps_utils_1.HandlerType.OnTransaction:
+        case snaps_utils_1.HandlerType.OnSignature:
+        case snaps_utils_1.HandlerType.OnHomePage: {
+            // Since this type has been asserted earlier we can cast
+            const castResult = result;
+            // If a handler returns static content, we turn it into a dynamic UI
+            if (castResult && (0, utils_1.hasProperty)(castResult, 'content')) {
+                const { content, ...rest } = castResult;
+                const id = await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_createInterface).call(this, snapId, content);
+                return { ...rest, id };
+            }
+            return result;
+        }
+        default:
+            return result;
+    }
+}, _SnapController_assertSnapRpcRequestResult = 
+/**
+ * Assert that the returned result of a Snap RPC call is the expected shape.
+ *
+ * @param snapId - The snap ID.
+ * @param handlerType - The handler type of the RPC Request.
+ * @param result - The result of the RPC request.
+ */
+async function _SnapController_assertSnapRpcRequestResult(snapId, handlerType, result) {
+    switch (handlerType) {
+        case snaps_utils_1.HandlerType.OnTransaction: {
+            (0, utils_1.assertStruct)(result, snaps_utils_1.OnTransactionResponseStruct);
+            if (result && (0, utils_1.hasProperty)(result, 'id')) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertInterfaceExists).call(this, snapId, result.id);
+            }
+            break;
+        }
+        case snaps_utils_1.HandlerType.OnSignature: {
+            (0, utils_1.assertStruct)(result, snaps_utils_1.OnSignatureResponseStruct);
+            if (result && (0, utils_1.hasProperty)(result, 'id')) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertInterfaceExists).call(this, snapId, result.id);
+            }
+            break;
+        }
+        case snaps_utils_1.HandlerType.OnHomePage: {
+            (0, utils_1.assertStruct)(result, snaps_utils_1.OnHomePageResponseStruct);
+            if (result && (0, utils_1.hasProperty)(result, 'id')) {
+                __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_assertInterfaceExists).call(this, snapId, result.id);
+            }
+            break;
+        }
+        case snaps_utils_1.HandlerType.OnNameLookup:
+            (0, utils_1.assertStruct)(result, snaps_utils_1.OnNameLookupResponseStruct);
+            break;
+        default:
+            break;
+    }
+}, _SnapController_recordSnapRpcRequestStart = function _SnapController_recordSnapRpcRequestStart(snapId, requestId, timer) {
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    runtime.pendingInboundRequests.push({ requestId, timer });
+    runtime.lastRequest = null;
+}, _SnapController_recordSnapRpcRequestFinish = function _SnapController_recordSnapRpcRequestFinish(snapId, requestId) {
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntimeExpect).call(this, snapId);
+    runtime.pendingInboundRequests = runtime.pendingInboundRequests.filter((request) => request.requestId !== requestId);
+    if (runtime.pendingInboundRequests.length === 0) {
+        runtime.lastRequest = Date.now();
+    }
+}, _SnapController_getRollbackSnapshot = function _SnapController_getRollbackSnapshot(snapId) {
+    return __classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").get(snapId);
+}, _SnapController_createRollbackSnapshot = function _SnapController_createRollbackSnapshot(snapId) {
+    (0, utils_1.assert)(__classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").get(snapId) === undefined, new Error(`Snap "${snapId}" rollback snapshot already exists.`));
+    __classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").set(snapId, {
+        statePatches: [],
+        permissions: {},
+        newVersion: '',
+    });
+    const newRollbackSnapshot = __classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").get(snapId);
+    (0, utils_1.assert)(newRollbackSnapshot !== undefined, new Error(`Snapshot creation failed for ${snapId}.`));
+    return newRollbackSnapshot;
+}, _SnapController_rollbackSnap = 
+/**
+ * Rolls back a snap to its previous state, permissions
+ * and source code based on the `RollbackSnapshot` that
+ * is captured during the update process. After rolling back,
+ * the function also emits an event indicating that the
+ * snap has been rolled back and it clears the snapshot
+ * for that snap.
+ *
+ * @param snapId - The snap id.
+ * @throws {@link Error}. If a snapshot does not exist.
+ */
+async function _SnapController_rollbackSnap(snapId) {
+    const rollbackSnapshot = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRollbackSnapshot).call(this, snapId);
+    if (!rollbackSnapshot) {
+        throw new Error('A snapshot does not exist for this snap.');
+    }
+    await this.stopSnap(snapId, snaps_utils_1.SnapStatusEvents.Stop);
+    // Always set to stopped even if it wasn't running initially
+    if (this.get(snapId)?.status !== snaps_utils_1.SnapStatus.Stopped) {
+        __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_transition).call(this, snapId, snaps_utils_1.SnapStatusEvents.Stop);
+    }
+    const { statePatches, permissions } = rollbackSnapshot;
+    if (statePatches?.length) {
+        this.applyPatches(statePatches);
+    }
+    // Reset snap status, as we may have been in another state when we stored state patches
+    // But now we are 100% in a stopped state
+    if (this.get(snapId)?.status !== snaps_utils_1.SnapStatus.Stopped) {
+        this.update((state) => {
+            state.snaps[snapId].status = snaps_utils_1.SnapStatus.Stopped;
+        });
+    }
+    __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_updatePermissions).call(this, {
+        snapId,
+        unusedPermissions: permissions.granted,
+        newPermissions: permissions.revoked,
+        requestData: permissions.requestData,
+    });
+    const truncatedSnap = this.getTruncatedExpect(snapId);
+    this.messagingSystem.publish('SnapController:snapRolledback', truncatedSnap, rollbackSnapshot.newVersion);
+    __classPrivateFieldGet(this, _SnapController_rollbackSnapshots, "f").delete(snapId);
+}, _SnapController_rollbackSnaps = 
+/**
+ * Iterates through an array of snap ids
+ * and calls `rollbackSnap` on them.
+ *
+ * @param snapIds - An array of snap ids.
+ */
+async function _SnapController_rollbackSnaps(snapIds) {
+    for (const snapId of snapIds) {
+        await __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_rollbackSnap).call(this, snapId);
+    }
+}, _SnapController_getRuntime = function _SnapController_getRuntime(snapId) {
+    return __classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").get(snapId);
+}, _SnapController_getRuntimeExpect = function _SnapController_getRuntimeExpect(snapId) {
+    const runtime = __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_getRuntime).call(this, snapId);
+    (0, utils_1.assert)(runtime !== undefined, new Error(`Snap "${snapId}" runtime data not found`));
+    return runtime;
+}, _SnapController_setupRuntime = function _SnapController_setupRuntime(snapId) {
+    if (__classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").has(snapId)) {
+        return;
+    }
+    const snap = this.get(snapId);
+    const interpreter = (0, fsm_1.interpret)(__classPrivateFieldGet(this, _SnapController_statusMachine, "f"));
+    interpreter.start({
+        context: { snapId },
+        value: snap?.status ??
+            __classPrivateFieldGet(this, _SnapController_statusMachine, "f").config.initial,
+    });
+    (0, fsm_2.forceStrict)(interpreter);
+    __classPrivateFieldGet(this, _SnapController_snapsRuntimeData, "f").set(snapId, {
+        lastRequest: null,
+        rpcHandler: null,
+        installPromise: null,
+        encryptionKey: null,
+        encryptionSalt: null,
+        activeReferences: 0,
+        pendingInboundRequests: [],
+        pendingOutboundRequests: 0,
+        interpreter,
+        stopping: false,
+    });
+}, _SnapController_calculatePermissionsChange = function _SnapController_calculatePermissionsChange(snapId, desiredPermissionsSet) {
+    const oldPermissions = this.messagingSystem.call('PermissionController:getPermissions', snapId) ?? {};
+    const newPermissions = (0, utils_2.permissionsDiff)(desiredPermissionsSet, oldPermissions);
+    // TODO(ritave): The assumption that these are unused only holds so long as we do not
+    //               permit dynamic permission requests.
+    const unusedPermissions = (0, utils_2.permissionsDiff)(oldPermissions, desiredPermissionsSet);
+    // It's a Set Intersection of oldPermissions and desiredPermissionsSet
+    // oldPermissions ∖ (oldPermissions ∖ desiredPermissionsSet) ⟺ oldPermissions ∩ desiredPermissionsSet
+    const approvedPermissions = (0, utils_2.permissionsDiff)(oldPermissions, unusedPermissions);
+    return { newPermissions, unusedPermissions, approvedPermissions };
+}, _SnapController_isSubjectConnectedToSnap = function _SnapController_isSubjectConnectedToSnap(snapId, origin) {
+    const subjectPermissions = this.messagingSystem.call('PermissionController:getPermissions', origin);
+    const existingCaveat = subjectPermissions?.[snaps_rpc_methods_1.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat) => caveat.type === snaps_utils_1.SnapCaveatType.SnapIds);
+    return Boolean(existingCaveat?.value?.[snapId]);
+}, _SnapController_calculateConnectionsChange = function _SnapController_calculateConnectionsChange(snapId, oldConnectionsSet, desiredConnectionsSet) {
+    // Filter out any origins that have been revoked since last install/update.
+    // That way they will be represented as new.
+    const filteredOldConnections = Object.keys(oldConnectionsSet)
+        .filter((origin) => __classPrivateFieldGet(this, _SnapController_instances, "m", _SnapController_isSubjectConnectedToSnap).call(this, snapId, origin))
+        .reduce((accumulator, origin) => {
+        accumulator[origin] = oldConnectionsSet[origin];
+        return accumulator;
+    }, {});
+    const newConnections = (0, utils_2.setDiff)(desiredConnectionsSet, filteredOldConnections);
+    const unusedConnections = (0, utils_2.setDiff)(filteredOldConnections, desiredConnectionsSet);
+    // It's a Set Intersection of oldConnections and desiredConnectionsSet
+    // oldConnections ∖ (oldConnections ∖ desiredConnectionsSet) ⟺ oldConnections ∩ desiredConnectionsSet
+    const approvedConnections = (0, utils_2.setDiff)(filteredOldConnections, unusedConnections);
+    return { newConnections, unusedConnections, approvedConnections };
+}, _SnapController_updatePermissions = function _SnapController_updatePermissions({ snapId, unusedPermissions = {}, newPermissions = {}, requestData, }) {
+    const unusedPermissionsKeys = Object.keys(unusedPermissions);
+    if ((0, utils_1.isNonEmptyArray)(unusedPermissionsKeys)) {
+        this.messagingSystem.call('PermissionController:revokePermissions', {
+            [snapId]: unusedPermissionsKeys,
+        });
+    }
+    if ((0, utils_1.isNonEmptyArray)(Object.keys(newPermissions))) {
+        this.messagingSystem.call('PermissionController:grantPermissions', {
+            approvedPermissions: newPermissions,
+            subject: { origin: snapId },
+            requestData,
+        });
+    }
+}, _SnapController_isValidUpdate = function _SnapController_isValidUpdate(snapId, newVersionRange) {
+    const existingSnap = this.getExpect(snapId);
+    if ((0, utils_1.satisfiesVersionRange)(existingSnap.version, newVersionRange)) {
+        return false;
+    }
+    if ((0, utils_1.gtRange)(existingSnap.version, newVersionRange)) {
+        return false;
+    }
+    return true;
+}, _SnapController_callLifecycleHook = 
+/**
+ * Call a lifecycle hook on a snap, if the snap has the
+ * `endowment:lifecycle-hooks` permission. If the snap does not have the
+ * permission, nothing happens.
+ *
+ * @param origin - The origin.
+ * @param snapId - The snap ID.
+ * @param handler - The lifecycle hook to call. This should be one of the
+ * supported lifecycle hooks.
+ * @private
+ */
+async function _SnapController_callLifecycleHook(origin, snapId, handler) {
+    const permissionName = snaps_rpc_methods_1.handlerEndowments[handler];
+    (0, utils_1.assert)(permissionName, 'Lifecycle hook must have an endowment.');
+    const hasPermission = this.messagingSystem.call('PermissionController:hasPermission', snapId, permissionName);
+    if (!hasPermission) {
+        return;
+    }
+    await this.handleRequest({
+        snapId,
+        handler,
+        origin,
+        request: {
+            jsonrpc: '2.0',
+            method: handler,
+        },
+    });
+};
+//# sourceMappingURL=SnapController.cjs.map