@metamask/snaps-controllers 4.0.0 → 5.0.0

package/dist/cjs/snaps/SnapController.js

@@ -37,11 +37,8 @@ const _nanoid = require("nanoid");
 const _fsm1 = require("../fsm");
 const _logging = require("../logging");
 const _utils1 = require("../utils");
-const _endowments = require("./endowments");
-const _keyring = require("./endowments/keyring");
-const _rpc = require("./endowments/rpc");
+const _constants = require("./constants");
 const _location = require("./location");
-const _permissions = require("./permissions");
 const _registry = require("./registry");
 const _RequestQueue = require("./RequestQueue");
 const _Timer = require("./Timer");
@@ -151,7 +148,7 @@ var _closeAllConnections = /*#__PURE__*/ new WeakMap(), _dynamicPermissions = /*
 _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    * Constructor helper for registering the controller's messaging system
    * actions.
-   */ _registerMessageHandlers = /*#__PURE__*/ new WeakSet(), _pollForLastRequestStatus = /*#__PURE__*/ new WeakSet(), _blockSnap = /*#__PURE__*/ new WeakSet(), /**
+   */ _registerMessageHandlers = /*#__PURE__*/ new WeakSet(), _handlePreinstalledSnaps = /*#__PURE__*/ new WeakSet(), _pollForLastRequestStatus = /*#__PURE__*/ new WeakSet(), _blockSnap = /*#__PURE__*/ new WeakSet(), /**
    * Unblocks a snap so that it can be enabled and started again. Emits
    * {@link SnapUnblocked}. Does nothing if the snap is not installed or already
    * unblocked.
@@ -168,7 +165,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    *
    * @param snapId - The id of the snap to transition.
    * @param event - The event enum to use to transition.
-   */ _transition = /*#__PURE__*/ new WeakSet(), _terminateSnap = /*#__PURE__*/ new WeakSet(), /**
+   */ _transition = /*#__PURE__*/ new WeakSet(), _terminateSnap = /*#__PURE__*/ new WeakSet(), _handleInitialConnections = /*#__PURE__*/ new WeakSet(), _addSnapToSubject = /*#__PURE__*/ new WeakSet(), /**
    * Removes a snap's permission (caveat) from all subjects.
    *
    * @param snapId - The id of the Snap.
@@ -189,12 +186,20 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    *
    * @param args - The add snap args.
    * @returns The resulting snap object.
-   */ _set = /*#__PURE__*/ new WeakSet(), _fetchSnap = /*#__PURE__*/ new WeakSet(), _validateSnapPermissions = /*#__PURE__*/ new WeakSet(), /**
+   */ _set = /*#__PURE__*/ new WeakSet(), _validateSnapPermissions = /*#__PURE__*/ new WeakSet(), /**
+   * Determine the execution timeout for a given handler permission.
+   *
+   * If no permission is specified or the permission itself has no execution timeout defined
+   * the constructor argument `maxRequestTime` will be used.
+   *
+   * @param permission - An optional permission constraint for the handler being called.
+   * @returns The execution timeout for the given handler.
+   */ _getExecutionTimeout = /*#__PURE__*/ new WeakSet(), /**
    * Gets the RPC message handler for the given snap.
    *
    * @param snapId - The id of the Snap whose message handler to get.
    * @returns The RPC handler for the given snap.
-   */ _getRpcRequestHandler = /*#__PURE__*/ new WeakSet(), _triggerPhishingListUpdate = /*#__PURE__*/ new WeakSet(), _checkPhishingList = /*#__PURE__*/ new WeakSet(), _assertSnapRpcRequestResult = /*#__PURE__*/ new WeakSet(), _executeWithTimeout = /*#__PURE__*/ new WeakSet(), _recordSnapRpcRequestStart = /*#__PURE__*/ new WeakSet(), _recordSnapRpcRequestFinish = /*#__PURE__*/ new WeakSet(), /**
+   */ _getRpcRequestHandler = /*#__PURE__*/ new WeakSet(), _createInterface = /*#__PURE__*/ new WeakSet(), _assertInterfaceExists = /*#__PURE__*/ new WeakSet(), _transformSnapRpcRequestResult = /*#__PURE__*/ new WeakSet(), _assertSnapRpcRequestResult = /*#__PURE__*/ new WeakSet(), _executeWithTimeout = /*#__PURE__*/ new WeakSet(), _recordSnapRpcRequestStart = /*#__PURE__*/ new WeakSet(), _recordSnapRpcRequestFinish = /*#__PURE__*/ new WeakSet(), /**
    * Retrieves the rollback snapshot of a snap.
    *
    * @param snapId - The snap id.
@@ -207,6 +212,16 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    * @throws {@link Error}. If the snap exists before creation or if creation fails.
    * @returns A `RollbackSnapshot`.
    */ _createRollbackSnapshot = /*#__PURE__*/ new WeakSet(), _rollbackSnap = /*#__PURE__*/ new WeakSet(), _rollbackSnaps = /*#__PURE__*/ new WeakSet(), _getRuntime = /*#__PURE__*/ new WeakSet(), _getRuntimeExpect = /*#__PURE__*/ new WeakSet(), _setupRuntime = /*#__PURE__*/ new WeakSet(), _calculatePermissionsChange = /*#__PURE__*/ new WeakSet(), /**
+   * Updates the permissions for a snap following an install, update or rollback.
+   *
+   * Grants newly requested permissions and revokes unused/revoked permissions.
+   *
+   * @param args - An options bag.
+   * @param args.snapId - The snap ID.
+   * @param args.newPermissions - New permissions to be granted.
+   * @param args.unusedPermissions - Unused permissions to be revoked.
+   * @param args.requestData - Optional request data from an approval.
+   */ _updatePermissions = /*#__PURE__*/ new WeakSet(), /**
    * Checks if a snap will pass version validation checks
    * with the new version range that is requested. The first
    * check that is done is to check if the existing snap version
@@ -492,6 +507,10 @@ class SnapController extends _basecontroller.BaseController {
         if (!Array.isArray(snapIds)) {
             throw new Error('Expected array of snap ids.');
         }
+        snapIds.forEach((snapId)=>{
+            const snap = this.getExpect(snapId);
+            (0, _utils.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);
@@ -685,6 +704,7 @@ class SnapController extends _basecontroller.BaseController {
             snapId,
             type: 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, _snapsutils.SnapStatusEvents.Stop);
@@ -718,11 +738,13 @@ class SnapController extends _basecontroller.BaseController {
             return truncated;
         } catch (error) {
             (0, _snapsutils.logError)(`Error when adding ${snapId}.`, error);
+            const errorString = error instanceof Error ? error.message : error.toString();
             _class_private_method_get(this, _updateApproval, updateApproval).call(this, pendingApproval.id, {
                 loading: false,
                 type: SNAP_APPROVAL_INSTALL,
-                error: error instanceof Error ? error.message : error.toString()
+                error: errorString
             });
+            this.messagingSystem.publish('SnapController:snapInstallFailed', snapId, origin, false, errorString);
             throw error;
         }
     }
@@ -754,9 +776,11 @@ class SnapController extends _basecontroller.BaseController {
             type: SNAP_APPROVAL_UPDATE
         });
         try {
+            this.messagingSystem.publish('SnapController:snapInstallStarted', snapId, origin, true);
             const snap = this.getExpect(snapId);
-            const newSnap = await _class_private_method_get(this, _fetchSnap, fetchSnap).call(this, snapId, location);
-            const { sourceCode: sourceCodeFile, manifest: manifestFile } = newSnap.files;
+            const oldManifest = snap.manifest;
+            const newSnap = await (0, _utils1.fetchSnap)(snapId, location);
+            const { sourceCode: sourceCodeFile, manifest: manifestFile } = newSnap;
             const manifest = manifestFile.result;
             const newVersion = manifest.version;
             if (!(0, _utils.gtVersion)(newVersion, snap.version)) {
@@ -767,9 +791,10 @@ class SnapController extends _basecontroller.BaseController {
             }
             await _class_private_method_get(this, _assertIsInstallAllowed, assertIsInstallAllowed).call(this, snapId, {
                 version: newVersion,
-                checksum: manifest.source.shasum
+                checksum: manifest.source.shasum,
+                permissions: manifest.initialPermissions
             });
-            const processedPermissions = (0, _permissions.processSnapPermissions)(manifest.initialPermissions);
+            const processedPermissions = (0, _snapsrpcmethods.processSnapPermissions)(manifest.initialPermissions);
             _class_private_method_get(this, _validateSnapPermissions, validateSnapPermissions).call(this, processedPermissions);
             const { newPermissions, unusedPermissions, approvedPermissions } = _class_private_method_get(this, _calculatePermissionsChange, calculatePermissionsChange).call(this, snapId, processedPermissions);
             _class_private_method_get(this, _updateApproval, updateApproval).call(this, pendingApproval.id, {
@@ -793,28 +818,22 @@ class SnapController extends _basecontroller.BaseController {
             _class_private_method_get(this, _set, set).call(this, {
                 origin,
                 id: snapId,
-                files: newSnap.files,
+                files: newSnap,
                 isUpdate: true
             });
-            const unusedPermissionsKeys = Object.keys(unusedPermissions);
-            if ((0, _utils.isNonEmptyArray)(unusedPermissionsKeys)) {
-                this.messagingSystem.call('PermissionController:revokePermissions', {
-                    [snapId]: unusedPermissionsKeys
-                });
-            }
-            if ((0, _utils.isNonEmptyArray)(Object.keys(approvedNewPermissions))) {
-                this.messagingSystem.call('PermissionController:grantPermissions', {
-                    approvedPermissions: approvedNewPermissions,
-                    subject: {
-                        origin: snapId
-                    },
-                    requestData
-                });
+            _class_private_method_get(this, _updatePermissions, updatePermissions).call(this, {
+                snapId,
+                unusedPermissions,
+                newPermissions: approvedNewPermissions,
+                requestData
+            });
+            if (manifest.initialConnections) {
+                _class_private_method_get(this, _handleInitialConnections, handleInitialConnections).call(this, snapId, oldManifest.initialConnections ?? null, manifest.initialConnections);
             }
             const rollbackSnapshot = _class_private_method_get(this, _getRollbackSnapshot, getRollbackSnapshot).call(this, snapId);
             if (rollbackSnapshot !== undefined) {
                 rollbackSnapshot.permissions.revoked = unusedPermissions;
-                rollbackSnapshot.permissions.granted = Object.keys(approvedNewPermissions);
+                rollbackSnapshot.permissions.granted = approvedNewPermissions;
                 rollbackSnapshot.permissions.requestData = requestData;
             }
             const sourceCode = sourceCodeFile.toString();
@@ -838,11 +857,13 @@ class SnapController extends _basecontroller.BaseController {
             return truncatedSnap;
         } catch (error) {
             (0, _snapsutils.logError)(`Error when updating ${snapId},`, error);
+            const errorString = error instanceof Error ? error.message : error.toString();
             _class_private_method_get(this, _updateApproval, updateApproval).call(this, pendingApproval.id, {
                 loading: false,
-                error: error instanceof Error ? error.message : error.toString(),
+                error: errorString,
                 type: SNAP_APPROVAL_UPDATE
             });
+            this.messagingSystem.publish('SnapController:snapInstallFailed', snapId, origin, true, errorString);
             throw error;
         }
     }
@@ -870,21 +891,20 @@ class SnapController extends _basecontroller.BaseController {
         const snap = snapsState[snapId];
         const { initialPermissions } = snap;
         try {
-            const processedPermissions = (0, _permissions.processSnapPermissions)(initialPermissions);
+            const processedPermissions = (0, _snapsrpcmethods.processSnapPermissions)(initialPermissions);
             _class_private_method_get(this, _validateSnapPermissions, validateSnapPermissions).call(this, processedPermissions);
             _class_private_method_get(this, _updateApproval, updateApproval).call(this, pendingApproval.id, {
                 loading: false,
                 permissions: processedPermissions
             });
             const { permissions: approvedPermissions, ...requestData } = await pendingApproval.promise;
-            if ((0, _utils.isNonEmptyArray)(Object.keys(approvedPermissions))) {
-                this.messagingSystem.call('PermissionController:grantPermissions', {
-                    approvedPermissions,
-                    subject: {
-                        origin: snapId
-                    },
-                    requestData
-                });
+            _class_private_method_get(this, _updatePermissions, updatePermissions).call(this, {
+                snapId,
+                newPermissions: approvedPermissions,
+                requestData
+            });
+            if (snap.manifest.initialConnections) {
+                _class_private_method_get(this, _handleInitialConnections, handleInitialConnections).call(this, snapId, null, snap.manifest.initialConnections);
             }
         } finally{
             const runtime = _class_private_method_get(this, _getRuntimeExpect, getRuntimeExpect).call(this, snapId);
@@ -918,35 +938,38 @@ class SnapController extends _basecontroller.BaseController {
             ...rawRequest
         };
         (0, _utils.assertIsJsonRpcRequest)(request);
-        const permissionName = _endowments.handlerEndowments[handlerType];
-        const hasPermission = this.messagingSystem.call('PermissionController:hasPermission', snapId, permissionName);
-        if (!hasPermission) {
+        const permissionName = _snapsrpcmethods.handlerEndowments[handlerType];
+        (0, _utils.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.hasProperty)(permissions, permissionName))) {
             throw new Error(`Snap "${snapId}" is not permitted to use "${permissionName}".`);
         }
-        if (permissionName === _endowments.SnapEndowments.Rpc || permissionName === _endowments.SnapEndowments.Keyring) {
-            const subject = this.messagingSystem.call('SubjectMetadataController:getSubjectMetadata', origin);
-            const permissions = this.messagingSystem.call('PermissionController:getPermissions', snapId);
-            const handlerPermissions = permissions?.[permissionName];
+        const handlerPermissions = permissionName ? permissions[permissionName] : undefined;
+        if (permissionName === _snapsrpcmethods.SnapEndowments.Rpc || permissionName === _snapsrpcmethods.SnapEndowments.Keyring) {
             (0, _utils.assert)(handlerPermissions);
-            const origins = permissionName === _endowments.SnapEndowments.Rpc ? (0, _rpc.getRpcCaveatOrigins)(handlerPermissions) : (0, _keyring.getKeyringCaveatOrigins)(handlerPermissions);
+            const subject = this.messagingSystem.call('SubjectMetadataController:getSubjectMetadata', origin);
+            const origins = permissionName === _snapsrpcmethods.SnapEndowments.Rpc ? (0, _snapsrpcmethods.getRpcCaveatOrigins)(handlerPermissions) : (0, _snapsrpcmethods.getKeyringCaveatOrigins)(handlerPermissions);
             (0, _utils.assert)(origins);
             if (!(0, _snapsutils.isOriginAllowed)(origins, subject?.subjectType ?? _permissioncontroller.SubjectType.Website, origin)) {
                 throw new Error(`Snap "${snapId}" is not permitted to handle requests from "${origin}".`);
             }
         }
-        const handler = await _class_private_method_get(this, _getRpcRequestHandler, getRpcRequestHandler).call(this, snapId);
+        const handler = _class_private_method_get(this, _getRpcRequestHandler, getRpcRequestHandler).call(this, snapId);
         if (!handler) {
             throw new Error(`Snap RPC message handler not found for snap "${snapId}".`);
         }
+        const timeout = _class_private_method_get(this, _getExecutionTimeout, getExecutionTimeout).call(this, handlerPermissions);
         return handler({
             origin,
             handler: handlerType,
-            request
+            request,
+            timeout
         });
     }
     constructor({ closeAllConnections, messenger, state, dynamicPermissions = [
         'eth_accounts'
-    ], environmentEndowmentPermissions = [], excludedPermissions = {}, idleTimeCheckInterval = (0, _utils.inMilliseconds)(5, _utils.Duration.Second), maxIdleTime = (0, _utils.inMilliseconds)(30, _utils.Duration.Second), maxRequestTime = (0, _utils.inMilliseconds)(60, _utils.Duration.Second), fetchFunction = globalThis.fetch.bind(globalThis), featureFlags = {}, detectSnapLocation: detectSnapLocationFunction = _location.detectSnapLocation }){
+    ], environmentEndowmentPermissions = [], excludedPermissions = {}, idleTimeCheckInterval = (0, _utils.inMilliseconds)(5, _utils.Duration.Second), maxIdleTime = (0, _utils.inMilliseconds)(30, _utils.Duration.Second), maxRequestTime = (0, _utils.inMilliseconds)(60, _utils.Duration.Second), fetchFunction = globalThis.fetch.bind(globalThis), featureFlags = {}, detectSnapLocation: detectSnapLocationFunction = _location.detectSnapLocation, preinstalledSnaps }){
         super({
             messenger,
             metadata: {
@@ -984,6 +1007,7 @@ class SnapController extends _basecontroller.BaseController {
         });
         _class_private_method_init(this, _initializeStateMachine);
         _class_private_method_init(this, _registerMessageHandlers);
+        _class_private_method_init(this, _handlePreinstalledSnaps);
         _class_private_method_init(this, _pollForLastRequestStatus);
         /**
    * Blocks an installed snap and prevents it from being started again. Emits
@@ -1001,6 +1025,8 @@ class SnapController extends _basecontroller.BaseController {
    *
    * @param snapId - The snap to terminate.
    */ _class_private_method_init(this, _terminateSnap);
+        _class_private_method_init(this, _handleInitialConnections);
+        _class_private_method_init(this, _addSnapToSubject);
         _class_private_method_init(this, _removeSnapFromSubjects);
         _class_private_method_init(this, _revokeAllSnapPermissions);
         _class_private_method_init(this, _createApproval);
@@ -1028,20 +1054,29 @@ class SnapController extends _basecontroller.BaseController {
    * @returns An array of the names of the endowments.
    */ _class_private_method_init(this, _getEndowments);
         _class_private_method_init(this, _set);
-        /**
-   * Fetches the manifest and source code of a snap.
-   *
-   * @param snapId - The id of the Snap.
-   * @param location - Source from which snap will be fetched.
-   * @returns A tuple of the Snap manifest object and the Snap source code.
-   */ _class_private_method_init(this, _fetchSnap);
         _class_private_method_init(this, _validateSnapPermissions);
+        _class_private_method_init(this, _getExecutionTimeout);
         _class_private_method_init(this, _getRpcRequestHandler);
-        _class_private_method_init(this, _triggerPhishingListUpdate);
-        _class_private_method_init(this, _checkPhishingList);
         /**
-   * Asserts that the returned result of a Snap RPC call is the expected shape.
+   * 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.
+   */ _class_private_method_init(this, _createInterface);
+        _class_private_method_init(this, _assertInterfaceExists);
+        /**
+   * 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.
+   */ _class_private_method_init(this, _transformSnapRpcRequestResult);
+        /**
+   * 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.
    */ _class_private_method_init(this, _assertSnapRpcRequestResult);
@@ -1079,6 +1114,7 @@ class SnapController extends _basecontroller.BaseController {
         _class_private_method_init(this, _getRuntimeExpect);
         _class_private_method_init(this, _setupRuntime);
         _class_private_method_init(this, _calculatePermissionsChange);
+        _class_private_method_init(this, _updatePermissions);
         _class_private_method_init(this, _isValidUpdate);
         /**
    * Call a lifecycle hook on a snap, if the snap has the
@@ -1175,7 +1211,10 @@ class SnapController extends _basecontroller.BaseController {
         });
         _class_private_method_get(this, _initializeStateMachine, initializeStateMachine).call(this);
         _class_private_method_get(this, _registerMessageHandlers, registerMessageHandlers).call(this);
-        Object.values(state?.snaps ?? {}).forEach((snap)=>_class_private_method_get(this, _setupRuntime, setupRuntime).call(this, snap.id));
+        if (preinstalledSnaps) {
+            _class_private_method_get(this, _handlePreinstalledSnaps, handlePreinstalledSnaps).call(this, preinstalledSnaps);
+        }
+        Object.values(this.state?.snaps ?? {}).forEach((snap)=>_class_private_method_get(this, _setupRuntime, setupRuntime).call(this, snap.id));
     }
 }
 function initializeStateMachine() {
@@ -1252,6 +1291,63 @@ function registerMessageHandlers() {
     this.messagingSystem.registerActionHandler(`${controllerName}:revokeDynamicPermissions`, (...args)=>this.revokeDynamicSnapPermissions(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:getFile`, async (...args)=>this.getSnapFile(...args));
 }
+function handlePreinstalledSnaps(preinstalledSnaps) {
+    for (const { snapId, manifest, files, removable } of preinstalledSnaps){
+        const existingSnap = this.get(snapId);
+        const isAlreadyInstalled = existingSnap !== undefined;
+        const isUpdate = isAlreadyInstalled && (0, _utils.gtVersion)(manifest.version, existingSnap.version);
+        // Disallow downgrades and overwriting non preinstalled snaps
+        if (isAlreadyInstalled && (!isUpdate || existingSnap.preinstalled !== true)) {
+            continue;
+        }
+        const manifestFile = new _snapsutils.VirtualFile({
+            path: _snapsutils.NpmSnapFileNames.Manifest,
+            value: JSON.stringify(manifest),
+            result: manifest
+        });
+        const virtualFiles = files.map(({ path, value })=>new _snapsutils.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.assert)(sourceCode, 'Source code not provided for preinstalled snap.');
+        (0, _utils.assert)(!iconPath || iconPath && svgIcon, 'Icon not provided for preinstalled snap.');
+        (0, _utils.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, _snapsutils.getValidatedLocalizationFiles)(localizationFiles.filter(Boolean));
+        (0, _utils.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
+        _class_private_method_get(this, _set, set).call(this, {
+            id: snapId,
+            origin: 'metamask',
+            files: filesObject,
+            removable,
+            preinstalled: true
+        });
+        // Setup permissions
+        const processedPermissions = (0, _snapsrpcmethods.processSnapPermissions)(manifest.initialPermissions);
+        _class_private_method_get(this, _validateSnapPermissions, validateSnapPermissions).call(this, processedPermissions);
+        const { newPermissions, unusedPermissions } = _class_private_method_get(this, _calculatePermissionsChange, calculatePermissionsChange).call(this, snapId, processedPermissions);
+        _class_private_method_get(this, _updatePermissions, updatePermissions).call(this, {
+            snapId,
+            newPermissions,
+            unusedPermissions
+        });
+        // Set status
+        this.update((state)=>{
+            state.snaps[snapId].status = _snapsutils.SnapStatus.Stopped;
+        });
+    }
+}
 function pollForLastRequestStatus() {
     _class_private_field_set(this, _timeoutForLastRequestStatus, setTimeout(()=>{
         _class_private_method_get(this, _stopSnapsLastRequestPastMax, stopSnapsLastRequestPastMax).call(this).catch((error)=>{
@@ -1293,7 +1389,9 @@ async function assertIsInstallAllowed(snapId, snapInfo) {
     const result = results[snapId];
     if (result.status === _registry.SnapsRegistryStatus.Blocked) {
         throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": The version is blocked. ${result.reason?.explanation ?? ''}`);
-    } else if (_class_private_field_get(this, _featureFlags).requireAllowlist && result.status !== _registry.SnapsRegistryStatus.Verified) {
+    }
+    const isAllowlistingRequired = Object.keys(snapInfo.permissions).some((permission)=>!_constants.ALLOWED_PERMISSIONS.includes(permission));
+    if (_class_private_field_get(this, _featureFlags).requireAllowlist && isAllowlistingRequired && result.status !== _registry.SnapsRegistryStatus.Verified) {
         throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": The snap is not on the allowlist.`);
     }
 }
@@ -1314,6 +1412,52 @@ async function terminateSnap(snapId) {
     await this.messagingSystem.call('ExecutionService:terminateSnap', snapId);
     this.messagingSystem.publish('SnapController:snapTerminated', this.getTruncatedExpect(snapId));
 }
+function handleInitialConnections(snapId, previousInitialConnections, initialConnections) {
+    if (previousInitialConnections) {
+        const revokedInitialConnections = (0, _utils1.setDiff)(previousInitialConnections, initialConnections);
+        for (const origin of Object.keys(revokedInitialConnections)){
+            this.removeSnapFromSubject(origin, snapId);
+        }
+    }
+    for (const origin of Object.keys(initialConnections)){
+        _class_private_method_get(this, _addSnapToSubject, addSnapToSubject).call(this, origin, snapId);
+    }
+}
+function addSnapToSubject(origin, snapId) {
+    const subjectPermissions = this.messagingSystem.call('PermissionController:getPermissions', origin);
+    const existingCaveat = subjectPermissions?.[_snapsrpcmethods.WALLET_SNAP_PERMISSION_KEY]?.caveats?.find((caveat)=>caveat.type === _snapsutils.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, _snapsrpcmethods.WALLET_SNAP_PERMISSION_KEY, _snapsutils.SnapCaveatType.SnapIds, {
+            ...existingCaveat,
+            [snapId]: {}
+        });
+        return;
+    }
+    const approvedPermissions = {
+        [_snapsrpcmethods.WALLET_SNAP_PERMISSION_KEY]: {
+            caveats: [
+                {
+                    type: _snapsutils.SnapCaveatType.SnapIds,
+                    value: {
+                        [snapId]: {}
+                    }
+                }
+            ]
+        }
+    };
+    this.messagingSystem.call('PermissionController:grantPermissions', {
+        approvedPermissions,
+        subject: {
+            origin
+        }
+    });
+}
 function removeSnapFromSubjects(snapId) {
     const subjects = this.messagingSystem.call('PermissionController:getSubjectNames');
     for (const subject of subjects){
@@ -1371,18 +1515,19 @@ async function add(args) {
         // If fetching and setting the snap succeeds, this property will be set
         // to null in the authorize() method.
         runtime.installPromise = (async ()=>{
-            const fetchedSnap = await _class_private_method_get(this, _fetchSnap, fetchSnap).call(this, snapId, location);
-            const manifest = fetchedSnap.files.manifest.result;
+            const fetchedSnap = await (0, _utils1.fetchSnap)(snapId, location);
+            const manifest = fetchedSnap.manifest.result;
             if (!(0, _utils.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 _class_private_method_get(this, _assertIsInstallAllowed, assertIsInstallAllowed).call(this, snapId, {
                 version: manifest.version,
-                checksum: manifest.source.shasum
+                checksum: manifest.source.shasum,
+                permissions: manifest.initialPermissions
             });
             return _class_private_method_get(this, _set, set).call(this, {
                 ...args,
-                ...fetchedSnap,
+                files: fetchedSnap,
                 id: snapId
             });
         })();
@@ -1445,10 +1590,10 @@ async function getEndowments(snapId) {
     return dedupedEndowments;
 }
 function set(args) {
-    const { id: snapId, origin, files, isUpdate = false } = args;
+    const { id: snapId, origin, files, isUpdate = false, removable, preinstalled } = args;
     const { manifest, sourceCode: sourceCodeFile, svgIcon, auxiliaryFiles: rawAuxiliaryFiles, localizationFiles } = files;
     (0, _snapsutils.assertIsSnapManifest)(manifest.result);
-    const { version, proposedName } = manifest.result;
+    const { version } = manifest.result;
     const sourceCode = sourceCodeFile.toString();
     (0, _utils.assert)(typeof sourceCode === 'string' && sourceCode.length > 0, `Invalid source code for snap "${snapId}".`);
     const auxiliaryFiles = rawAuxiliaryFiles.map((file)=>{
@@ -1469,6 +1614,7 @@ function set(args) {
             origin
         }
     ];
+    const localizedFiles = localizationFiles.map((file)=>file.result);
     const snap = {
         // Restore relevant snap state if it exists
         ...existingSnap,
@@ -1476,6 +1622,8 @@ function set(args) {
         // previous state.
         blocked: false,
         enabled: true,
+        removable,
+        preinstalled,
         id: snapId,
         initialPermissions: manifest.result.initialPermissions,
         manifest: manifest.result,
@@ -1484,7 +1632,7 @@ function set(args) {
         version,
         versionHistory,
         auxiliaryFiles,
-        localizationFiles: localizationFiles.map((file)=>file.result)
+        localizationFiles: localizedFiles
     };
     // If the snap was blocked, it isn't any longer
     delete snap.blockInformation;
@@ -1500,6 +1648,9 @@ function set(args) {
             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, _snapsutils.getLocalizedSnapManifest)(manifest.result, 'en', localizedFiles);
     this.messagingSystem.call('SubjectMetadataController:addSubjectMetadata', {
         subjectType: _permissioncontroller.SubjectType.Snap,
         name: proposedName,
@@ -1512,40 +1663,10 @@ function set(args) {
         sourceCode
     };
 }
-async function fetchSnap(snapId, location) {
-    try {
-        const manifest = await location.manifest();
-        const sourceCode = await location.fetch(manifest.result.source.location.npm.filePath);
-        const { iconPath } = manifest.result.source.location.npm;
-        const svgIcon = iconPath ? await location.fetch(iconPath) : undefined;
-        const auxiliaryFiles = await (0, _utils1.getSnapFiles)(location, manifest.result.source.files);
-        await Promise.all(auxiliaryFiles.map(async (file)=>{
-            // This should still be safe
-            // eslint-disable-next-line require-atomic-updates
-            file.data.base64 = await (0, _snapsutils.encodeBase64)(file);
-        }));
-        const localizationFiles = await (0, _utils1.getSnapFiles)(location, manifest.result.source.locales);
-        const validatedLocalizationFiles = (0, _snapsutils.getValidatedLocalizationFiles)(localizationFiles);
-        const files = {
-            manifest,
-            sourceCode,
-            svgIcon,
-            auxiliaryFiles,
-            localizationFiles: validatedLocalizationFiles
-        };
-        await (0, _snapsutils.validateFetchedSnap)(files);
-        return {
-            files,
-            location
-        };
-    } catch (error) {
-        throw new Error(`Failed to fetch snap "${snapId}": ${(0, _snapssdk.getErrorMessage)(error)}.`);
-    }
-}
 function validateSnapPermissions(processedPermissions) {
     const permissionKeys = Object.keys(processedPermissions);
-    const handlerPermissions = Array.from(new Set(Object.values(_endowments.handlerEndowments)));
-    (0, _utils.assert)(permissionKeys.some((key)=>handlerPermissions.includes(key)), `A snap must request at least one of the following permissions: ${handlerPermissions.join(', ')}.`);
+    const handlerPermissions = Array.from(new Set(Object.values(_snapsrpcmethods.handlerEndowments)));
+    (0, _utils.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.hasProperty)(_class_private_field_get(this, _excludedPermissions), permission)) {
             errors.push(_class_private_field_get(this, _excludedPermissions)[permission]);
@@ -1554,6 +1675,9 @@ function validateSnapPermissions(processedPermissions) {
     }, []);
     (0, _utils.assert)(excludedPermissionErrors.length === 0, `One or more permissions are not allowed:\n${excludedPermissionErrors.join('\n')}`);
 }
+function getExecutionTimeout(permission) {
+    return (0, _snapsrpcmethods.getMaxRequestTimeCaveat)(permission) ?? this.maxRequestTime;
+}
 function getRpcRequestHandler(snapId) {
     const runtime = _class_private_method_get(this, _getRuntimeExpect, getRuntimeExpect).call(this, snapId);
     const existingHandler = runtime.rpcHandler;
@@ -1564,7 +1688,7 @@ function getRpcRequestHandler(snapId) {
     // 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 })=>{
+    const rpcHandler = async ({ origin, handler: handlerType, request, timeout })=>{
         if (this.state.snaps[snapId].enabled === false) {
             throw new Error(`Snap "${snapId}" is disabled.`);
         }
@@ -1590,7 +1714,7 @@ function getRpcRequestHandler(snapId) {
                 }
             }
         }
-        const timer = new _Timer.Timer(this.maxRequestTime);
+        const timer = new _Timer.Timer(timeout);
         _class_private_method_get(this, _recordSnapRpcRequestStart, recordSnapRpcRequestStart).call(this, snapId, request.id, timer);
         const handleRpcRequestPromise = this.messagingSystem.call('ExecutionService:handleRpcRequest', snapId, {
             origin,
@@ -1600,8 +1724,8 @@ function getRpcRequestHandler(snapId) {
         // This will either get the result or reject due to the timeout.
         try {
             const result = await _class_private_method_get(this, _executeWithTimeout, executeWithTimeout).call(this, handleRpcRequestPromise, timer);
-            await _class_private_method_get(this, _assertSnapRpcRequestResult, assertSnapRpcRequestResult).call(this, handlerType, result);
-            return result;
+            await _class_private_method_get(this, _assertSnapRpcRequestResult, assertSnapRpcRequestResult).call(this, snapId, handlerType, result);
+            return _class_private_method_get(this, _transformSnapRpcRequestResult, transformSnapRpcRequestResult).call(this, snapId, handlerType, result);
         } catch (error) {
             const [jsonRpcError, handled] = (0, _snapsutils.unwrapError)(error);
             if (!handled) {
@@ -1615,29 +1739,64 @@ function getRpcRequestHandler(snapId) {
     runtime.rpcHandler = rpcHandler;
     return rpcHandler;
 }
-async function triggerPhishingListUpdate() {
-    return this.messagingSystem.call('PhishingController:maybeUpdateState');
+async function createInterface(snapId, content) {
+    return this.messagingSystem.call('SnapInterfaceController:createInterface', snapId, content);
+}
+function assertInterfaceExists(snapId, id) {
+    // This will throw if the interface isn't accessible, but we assert nevertheless.
+    (0, _utils.assert)(this.messagingSystem.call('SnapInterfaceController:getInterface', snapId, id));
 }
-function checkPhishingList(origin) {
-    return this.messagingSystem.call('PhishingController:testOrigin', origin).result;
+async function transformSnapRpcRequestResult(snapId, handlerType, result) {
+    switch(handlerType){
+        case _snapsutils.HandlerType.OnTransaction:
+        case _snapsutils.HandlerType.OnSignature:
+        case _snapsutils.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.hasProperty)(castResult, 'content')) {
+                    const { content, ...rest } = castResult;
+                    const id = await _class_private_method_get(this, _createInterface, createInterface).call(this, snapId, content);
+                    return {
+                        ...rest,
+                        id
+                    };
+                }
+                return result;
+            }
+        default:
+            return result;
+    }
 }
-async function assertSnapRpcRequestResult(handlerType, result) {
+async function assertSnapRpcRequestResult(snapId, handlerType, result) {
     switch(handlerType){
         case _snapsutils.HandlerType.OnTransaction:
             {
                 (0, _utils.assertStruct)(result, _snapsutils.OnTransactionResponseStruct);
-                // Null is an allowed return value here
-                if (result === null) {
-                    return;
+                if (result && (0, _utils.hasProperty)(result, 'id')) {
+                    _class_private_method_get(this, _assertInterfaceExists, assertInterfaceExists).call(this, snapId, result.id);
+                }
+                break;
+            }
+        case _snapsutils.HandlerType.OnSignature:
+            {
+                (0, _utils.assertStruct)(result, _snapsutils.OnSignatureResponseStruct);
+                if (result && (0, _utils.hasProperty)(result, 'id')) {
+                    _class_private_method_get(this, _assertInterfaceExists, assertInterfaceExists).call(this, snapId, result.id);
                 }
-                await _class_private_method_get(this, _triggerPhishingListUpdate, triggerPhishingListUpdate).call(this);
-                (0, _snapsutils.validateComponentLinks)(result.content, _class_private_method_get(this, _checkPhishingList, checkPhishingList).bind(this));
                 break;
             }
         case _snapsutils.HandlerType.OnHomePage:
-            (0, _utils.assertStruct)(result, _snapsutils.OnHomePageResponseStruct);
-            await _class_private_method_get(this, _triggerPhishingListUpdate, triggerPhishingListUpdate).call(this);
-            (0, _snapsutils.validateComponentLinks)(result.content, _class_private_method_get(this, _checkPhishingList, checkPhishingList).bind(this));
+            {
+                (0, _utils.assertStruct)(result, _snapsutils.OnHomePageResponseStruct);
+                if (result && (0, _utils.hasProperty)(result, 'id')) {
+                    _class_private_method_get(this, _assertInterfaceExists, assertInterfaceExists).call(this, snapId, result.id);
+                }
+                break;
+            }
+        case _snapsutils.HandlerType.OnNameLookup:
+            (0, _utils.assertStruct)(result, _snapsutils.OnNameLookupResponseStruct);
             break;
         default:
             break;
@@ -1672,11 +1831,7 @@ function createRollbackSnapshot(snapId) {
     (0, _utils.assert)(_class_private_field_get(this, _rollbackSnapshots).get(snapId) === undefined, new Error(`Snap "${snapId}" rollback snapshot already exists.`));
     _class_private_field_get(this, _rollbackSnapshots).set(snapId, {
         statePatches: [],
-        permissions: {
-            revoked: null,
-            granted: [],
-            requestData: null
-        },
+        permissions: {},
         newVersion: ''
     });
     const newRollbackSnapshot = _class_private_field_get(this, _rollbackSnapshots).get(snapId);
@@ -1704,20 +1859,12 @@ async function rollbackSnap(snapId) {
             state.snaps[snapId].status = _snapsutils.SnapStatus.Stopped;
         });
     }
-    if (permissions.revoked && Object.keys(permissions.revoked).length) {
-        this.messagingSystem.call('PermissionController:grantPermissions', {
-            approvedPermissions: permissions.revoked,
-            subject: {
-                origin: snapId
-            },
-            requestData: permissions.requestData
-        });
-    }
-    if (permissions.granted?.length) {
-        this.messagingSystem.call('PermissionController:revokePermissions', {
-            [snapId]: permissions.granted
-        });
-    }
+    _class_private_method_get(this, _updatePermissions, 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);
     _class_private_field_get(this, _rollbackSnapshots).delete(snapId);
@@ -1773,6 +1920,23 @@ function calculatePermissionsChange(snapId, desiredPermissionsSet) {
         approvedPermissions
     };
 }
+function updatePermissions({ snapId, unusedPermissions = {}, newPermissions = {}, requestData }) {
+    const unusedPermissionsKeys = Object.keys(unusedPermissions);
+    if ((0, _utils.isNonEmptyArray)(unusedPermissionsKeys)) {
+        this.messagingSystem.call('PermissionController:revokePermissions', {
+            [snapId]: unusedPermissionsKeys
+        });
+    }
+    if ((0, _utils.isNonEmptyArray)(Object.keys(newPermissions))) {
+        this.messagingSystem.call('PermissionController:grantPermissions', {
+            approvedPermissions: newPermissions,
+            subject: {
+                origin: snapId
+            },
+            requestData
+        });
+    }
+}
 function isValidUpdate(snapId, newVersionRange) {
     const existingSnap = this.getExpect(snapId);
     if ((0, _utils.satisfiesVersionRange)(existingSnap.version, newVersionRange)) {
@@ -1784,7 +1948,8 @@ function isValidUpdate(snapId, newVersionRange) {
     return true;
 }
 async function callLifecycleHook(snapId, handler) {
-    const permissionName = _endowments.handlerEndowments[handler];
+    const permissionName = _snapsrpcmethods.handlerEndowments[handler];
+    (0, _utils.assert)(permissionName, 'Lifecycle hook must have an endowment.');
     const hasPermission = this.messagingSystem.call('PermissionController:hasPermission', snapId, permissionName);
     if (!hasPermission) {
         return;