@metamask/snaps-controllers 4.1.0 → 5.0.0

package/dist/cjs/services/webview/WebViewMessageStream.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebViewMessageStream", {
+    enumerable: true,
+    get: function() {
+        return WebViewMessageStream;
+    }
+});
+const _postmessagestream = require("@metamask/post-message-stream");
+const _utils = require("@metamask/post-message-stream/dist/utils");
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils1 = require("@metamask/utils");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _name = /*#__PURE__*/ new WeakMap(), _target = /*#__PURE__*/ new WeakMap(), _webView = /*#__PURE__*/ new WeakMap();
+class WebViewMessageStream extends _postmessagestream.BasePostMessageStream {
+    _postMessage(data) {
+        (0, _utils1.assert)(_class_private_field_get(this, _webView));
+        const json = JSON.stringify({
+            target: _class_private_field_get(this, _target),
+            data
+        });
+        // To prevent XSS, we base64 encode the message before injecting it.
+        // This adds significant performance overhead.
+        // TODO: Should we use mobile native base64 here?
+        const bytes = (0, _utils1.stringToBytes)(json);
+        const base64 = (0, _utils1.bytesToBase64)(bytes);
+        _class_private_field_get(this, _webView).injectJavaScript(`window.postMessage('${base64}')`);
+    }
+    _onMessage(event) {
+        if (typeof event.data !== 'string') {
+            return;
+        }
+        const message = JSON.parse(event.data);
+        // Notice that we don't check targetWindow or targetOrigin here.
+        // This doesn't seem possible to do in RN.
+        if (!(0, _utils.isValidStreamMessage)(message) || message.target !== _class_private_field_get(this, _name)) {
+            return;
+        }
+        this._onData(message.data);
+    }
+    _destroy() {
+        (0, _utils1.assert)(_class_private_field_get(this, _webView));
+        // This method is already bound.
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        _class_private_field_get(this, _webView).unregisterMessageListener(this._onMessage);
+    }
+    /**
+   * Creates a stream for communicating with other streams inside a WebView.
+   *
+   * @param args - Options bag.
+   * @param args.name - The name of the stream. Used to differentiate between
+   * multiple streams sharing the same window object.
+   * @param args.target - The name of the stream to exchange messages with.
+   * @param args.getWebView - A asynchronous getter for the webview.
+   */ constructor({ name, target, getWebView }){
+        super();
+        _class_private_field_init(this, _name, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _target, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _webView, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _name, name);
+        _class_private_field_set(this, _target, target);
+        this._onMessage = this._onMessage.bind(this);
+        // This is a bit atypical from other post-message streams.
+        // We have to wait for the WebView to fully load before we can continue using the stream.
+        getWebView().then((webView)=>{
+            _class_private_field_set(this, _webView, webView);
+            // This method is already bound.
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            webView.registerMessageListener(this._onMessage);
+            this._handshake();
+        }).catch((error)=>{
+            (0, _snapsutils.logError)(error);
+        });
+    }
+}
+
+//# sourceMappingURL=WebViewMessageStream.js.map

package/dist/cjs/services/webview/WebViewMessageStream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/webview/WebViewMessageStream.ts"],"sourcesContent":["import type { PostMessageEvent } from '@metamask/post-message-stream';\nimport { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { isValidStreamMessage } from '@metamask/post-message-stream/dist/utils';\nimport { logError } from '@metamask/snaps-utils';\nimport { assert, bytesToBase64, stringToBytes } from '@metamask/utils';\n\nexport type WebViewInterface = {\n  injectJavaScript(js: string): void;\n  registerMessageListener(listener: (event: PostMessageEvent) => void): void;\n  unregisterMessageListener(listener: (event: PostMessageEvent) => void): void;\n};\n\ntype WebViewStreamArgs = {\n  name: string;\n  target: string;\n  getWebView: () => Promise<WebViewInterface>;\n};\n\n/**\n * A special postMessage stream used to interface with a WebView.\n */\n\nexport class WebViewMessageStream extends BasePostMessageStream {\n  #name;\n\n  #target;\n\n  #webView: WebViewInterface | undefined;\n\n  /**\n   * Creates a stream for communicating with other streams inside a WebView.\n   *\n   * @param args - Options bag.\n   * @param args.name - The name of the stream. Used to differentiate between\n   * multiple streams sharing the same window object.\n   * @param args.target - The name of the stream to exchange messages with.\n   * @param args.getWebView - A asynchronous getter for the webview.\n   */\n  constructor({ name, target, getWebView }: WebViewStreamArgs) {\n    super();\n\n    this.#name = name;\n    this.#target = target;\n\n    this._onMessage = this._onMessage.bind(this);\n\n    // This is a bit atypical from other post-message streams.\n    // We have to wait for the WebView to fully load before we can continue using the stream.\n    getWebView()\n      .then((webView) => {\n        this.#webView = webView;\n        // This method is already bound.\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        webView.registerMessageListener(this._onMessage);\n        this._handshake();\n      })\n      .catch((error) => {\n        logError(error);\n      });\n  }\n\n  protected _postMessage(data: unknown): void {\n    assert(this.#webView);\n    const json = JSON.stringify({\n      target: this.#target,\n      data,\n    });\n\n    // To prevent XSS, we base64 encode the message before injecting it.\n    // This adds significant performance overhead.\n    // TODO: Should we use mobile native base64 here?\n    const bytes = stringToBytes(json);\n    const base64 = bytesToBase64(bytes);\n    this.#webView.injectJavaScript(`window.postMessage('${base64}')`);\n  }\n\n  private _onMessage(event: PostMessageEvent): void {\n    if (typeof event.data !== 'string') {\n      return;\n    }\n\n    const message = JSON.parse(event.data);\n\n    // Notice that we don't check targetWindow or targetOrigin here.\n    // This doesn't seem possible to do in RN.\n    if (!isValidStreamMessage(message) || message.target !== this.#name) {\n      return;\n    }\n\n    this._onData(message.data);\n  }\n\n  _destroy() {\n    assert(this.#webView);\n    // This method is already bound.\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    this.#webView.unregisterMessageListener(this._onMessage);\n  }\n}\n"],"names":["WebViewMessageStream","BasePostMessageStream","_postMessage","data","assert","webView","json","JSON","stringify","target","bytes","stringToBytes","base64","bytesToBase64","injectJavaScript","_onMessage","event","message","parse","isValidStreamMessage","name","_onData","_destroy","unregisterMessageListener","constructor","getWebView","bind","then","registerMessageListener","_handshake","catch","error","logError"],"mappings":";;;;+BAsBaA;;;eAAAA;;;mCArByB;uBACD;4BACZ;wBAC4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBnD,qCAEA,uCAEA;AALK,MAAMA,6BAA6BC,wCAAqB;IAuCnDC,aAAaC,IAAa,EAAQ;QAC1CC,IAAAA,cAAM,2BAAC,IAAI,EAAEC;QACb,MAAMC,OAAOC,KAAKC,SAAS,CAAC;YAC1BC,MAAM,2BAAE,IAAI,EAAEA;YACdN;QACF;QAEA,oEAAoE;QACpE,8CAA8C;QAC9C,iDAAiD;QACjD,MAAMO,QAAQC,IAAAA,qBAAa,EAACL;QAC5B,MAAMM,SAASC,IAAAA,qBAAa,EAACH;QAC7B,yBAAA,IAAI,EAAEL,UAAQS,gBAAgB,CAAC,CAAC,oBAAoB,EAAEF,OAAO,EAAE,CAAC;IAClE;IAEQG,WAAWC,KAAuB,EAAQ;QAChD,IAAI,OAAOA,MAAMb,IAAI,KAAK,UAAU;YAClC;QACF;QAEA,MAAMc,UAAUV,KAAKW,KAAK,CAACF,MAAMb,IAAI;QAErC,gEAAgE;QAChE,0CAA0C;QAC1C,IAAI,CAACgB,IAAAA,2BAAoB,EAACF,YAAYA,QAAQR,MAAM,8BAAK,IAAI,EAAEW,QAAM;YACnE;QACF;QAEA,IAAI,CAACC,OAAO,CAACJ,QAAQd,IAAI;IAC3B;IAEAmB,WAAW;QACTlB,IAAAA,cAAM,2BAAC,IAAI,EAAEC;QACb,gCAAgC;QAChC,6DAA6D;QAC7D,yBAAA,IAAI,EAAEA,UAAQkB,yBAAyB,CAAC,IAAI,CAACR,UAAU;IACzD;IApEA;;;;;;;;GAQC,GACDS,YAAY,EAAEJ,IAAI,EAAEX,MAAM,EAAEgB,UAAU,EAAqB,CAAE;QAC3D,KAAK;QAhBP,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;uCAcQL,OAAOA;uCACPX,SAASA;QAEf,IAAI,CAACM,UAAU,GAAG,IAAI,CAACA,UAAU,CAACW,IAAI,CAAC,IAAI;QAE3C,0DAA0D;QAC1D,yFAAyF;QACzFD,aACGE,IAAI,CAAC,CAACtB;2CACCA,UAAUA;YAChB,gCAAgC;YAChC,6DAA6D;YAC7DA,QAAQuB,uBAAuB,CAAC,IAAI,CAACb,UAAU;YAC/C,IAAI,CAACc,UAAU;QACjB,GACCC,KAAK,CAAC,CAACC;YACNC,IAAAA,oBAAQ,EAACD;QACX;IACJ;AAuCF"}

package/dist/cjs/services/webview/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./WebViewExecutionService"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/services/webview/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/webview/index.ts"],"sourcesContent":["export * from './WebViewExecutionService';\n"],"names":[],"mappings":";;;;qBAAc"}

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");
@@ -190,11 +187,19 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    * @param args - The add snap args.
    * @returns The resulting snap object.
    */ _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.
@@ -786,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, {
@@ -885,7 +891,7 @@ 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,
@@ -932,30 +938,33 @@ 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 = [
@@ -1046,12 +1055,28 @@ class SnapController extends _basecontroller.BaseController {
    */ _class_private_method_init(this, _getEndowments);
         _class_private_method_init(this, _set);
         _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);
@@ -1309,7 +1334,7 @@ function handlePreinstalledSnaps(preinstalledSnaps) {
             preinstalled: true
         });
         // Setup permissions
-        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 } = _class_private_method_get(this, _calculatePermissionsChange, calculatePermissionsChange).call(this, snapId, processedPermissions);
         _class_private_method_get(this, _updatePermissions, updatePermissions).call(this, {
@@ -1364,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.`);
     }
 }
@@ -1495,7 +1522,8 @@ async function add(args) {
             }
             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,
@@ -1565,7 +1593,7 @@ function set(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)=>{
@@ -1586,6 +1614,7 @@ function set(args) {
             origin
         }
     ];
+    const localizedFiles = localizationFiles.map((file)=>file.result);
     const snap = {
         // Restore relevant snap state if it exists
         ...existingSnap,
@@ -1603,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;
@@ -1619,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,
@@ -1633,8 +1665,8 @@ function set(args) {
 }
 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]);
@@ -1643,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;
@@ -1653,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.`);
         }
@@ -1679,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,
@@ -1689,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) {
@@ -1704,40 +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 checkPhishingList(origin) {
-    return this.messagingSystem.call('PhishingController:testOrigin', origin).result;
+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));
 }
-async function assertSnapRpcRequestResult(handlerType, 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(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);
                 }
-                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.OnSignature:
             {
                 (0, _utils.assertStruct)(result, _snapsutils.OnSignatureResponseStruct);
-                // 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);
                 }
-                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;
@@ -1889,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;