@metamask/snaps-controllers 3.0.0 → 3.1.0

package/dist/esm/snaps/SnapController.js

@@ -63,11 +63,11 @@ function _define_property(obj, key, value) {
 }
 import { BaseControllerV2 as BaseController } from '@metamask/base-controller';
 import { SubjectType } from '@metamask/permission-controller';
-import { WALLET_SNAP_PERMISSION_KEY } from '@metamask/rpc-methods';
-import { assertIsSnapManifest, assertIsValidSnapId, DEFAULT_ENDOWMENTS, DEFAULT_REQUESTED_SNAP_VERSION, getErrorMessage, HandlerType, isOriginAllowed, logError, normalizeRelative, resolveVersionRange, SnapCaveatType, SnapStatus, SnapStatusEvents, validateFetchedSnap } from '@metamask/snaps-utils';
+import { rpcErrors } from '@metamask/rpc-errors';
+import { WALLET_SNAP_PERMISSION_KEY } from '@metamask/snaps-rpc-methods';
+import { assertIsSnapManifest, assertIsValidSnapId, AuxiliaryFileEncoding, DEFAULT_ENDOWMENTS, DEFAULT_REQUESTED_SNAP_VERSION, encodeAuxiliaryFile, getErrorMessage, HandlerType, isOriginAllowed, logError, normalizeRelative, resolveVersionRange, SnapCaveatType, SnapStatus, SnapStatusEvents, validateFetchedSnap, unwrapError } from '@metamask/snaps-utils';
 import { assert, assertIsJsonRpcRequest, Duration, gtRange, gtVersion, hasProperty, inMilliseconds, isNonEmptyArray, isValidSemVerRange, satisfiesVersionRange, timeSince } from '@metamask/utils';
 import { createMachine, interpret } from '@xstate/fsm';
-import { ethErrors } from 'eth-rpc-errors';
 import { nanoid } from 'nanoid';
 import { forceStrict, validateMachine } from '../fsm';
 import { log } from '../logging';
@@ -93,7 +93,6 @@ const TRUNCATED_SNAP_PROPERTIES = new Set([
     'blocked'
 ]);
 const defaultState = {
-    snapErrors: {},
     snaps: {},
     snapStates: {}
 };
@@ -149,7 +148,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
    * Safely revokes all permissions granted to a Snap.
    *
    * @param snapId - The snap ID.
-   */ _revokeAllSnapPermissions = /*#__PURE__*/ new WeakSet(), _createApproval = /*#__PURE__*/ new WeakSet(), _updateApproval = /*#__PURE__*/ new WeakSet(), _add = /*#__PURE__*/ new WeakSet(), _startSnap = /*#__PURE__*/ new WeakSet(), _getEndowments = /*#__PURE__*/ new WeakSet(), /**
+   */ _revokeAllSnapPermissions = /*#__PURE__*/ new WeakSet(), _createApproval = /*#__PURE__*/ new WeakSet(), _updateApproval = /*#__PURE__*/ new WeakSet(), _resolveAllowlistVersion = /*#__PURE__*/ new WeakSet(), _add = /*#__PURE__*/ new WeakSet(), _startSnap = /*#__PURE__*/ new WeakSet(), _getEndowments = /*#__PURE__*/ new WeakSet(), /**
    * Sets a snap in state. Called when a snap is installed or updated. Performs
    * various validation checks on the received arguments, and will throw if
    * validation fails.
@@ -220,8 +219,8 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
             return _class_private_method_get(this, _unblockSnap, unblockSnap).call(this, snapId);
         }));
     }
-    _onUnhandledSnapError(snapId, error) {
-        this.stopSnap(snapId, SnapStatusEvents.Crash).then(()=>this.addSnapError(error)).catch((stopSnapError)=>{
+    _onUnhandledSnapError(snapId, _error) {
+        this.stopSnap(snapId, SnapStatusEvents.Crash).catch((stopSnapError)=>{
             // TODO: Decide how to handle errors.
             logError(stopSnapError);
         });
@@ -397,35 +396,6 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         });
     }
     /**
-   * Adds error from a snap to the SnapController state.
-   *
-   * @param snapError - The error to store on the SnapController.
-   */ addSnapError(snapError) {
-        this.update((state)=>{
-            const id = nanoid();
-            state.snapErrors[id] = {
-                ...snapError,
-                internalID: id
-            };
-        });
-    }
-    /**
-   * Removes an error by internalID from the SnapControllers state.
-   *
-   * @param internalID - The internal error ID to remove on the SnapController.
-   */ removeSnapError(internalID) {
-        this.update((state)=>{
-            delete state.snapErrors[internalID];
-        });
-    }
-    /**
-   * Clears all errors from the SnapControllers state.
-   */ clearSnapErrors() {
-        this.update((state)=>{
-            state.snapErrors = {};
-        });
-    }
-    /**
    * Gets the own state of the snap with the given id.
    * This is distinct from the state MetaMask uses to manage snaps.
    *
@@ -437,6 +407,22 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         return state ?? null;
     }
     /**
+   * 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.
+   */ getSnapFile(snapId, path, encoding = AuxiliaryFileEncoding.Base64) {
+        const snap = this.getExpect(snapId);
+        const normalizedPath = normalizeRelative(path);
+        const value = snap.auxiliaryFiles?.find((file)=>file.path === normalizedPath)?.value;
+        if (!value) {
+            return null;
+        }
+        return encodeAuxiliaryFile(value, encoding);
+    }
+    /**
    * Completely clear the controller's state: delete all associated data,
    * handlers, event listeners, and permissions; tear down all snap providers.
    */ async clearState() {
@@ -590,10 +576,12 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         try {
             for (const [snapId, { version: rawVersion }] of Object.entries(requestedSnaps)){
                 assertIsValidSnapId(snapId);
-                const [error, version] = resolveVersionRange(rawVersion);
+                const [error, resolvedVersion] = resolveVersionRange(rawVersion);
                 if (error) {
-                    throw ethErrors.rpc.invalidParams(`The "version" field must be a valid SemVer version range if specified. Received: "${rawVersion}".`);
+                    throw rpcErrors.invalidParams(`The "version" field must be a valid SemVer version range if specified. Received: "${rawVersion}".`);
                 }
+                // If we are running in allowlist mode, try to match the version with an allowlist version.
+                const version = _class_private_field_get(this, _featureFlags).requireAllowlist ? await _class_private_method_get(this, _resolveAllowlistVersion, resolveAllowlistVersion).call(this, snapId, resolvedVersion) : resolvedVersion;
                 const location = _class_private_field_get(this, _detectSnapLocation).call(this, snapId, {
                     versionRange: version,
                     fetch: _class_private_field_get(this, _fetchFunction),
@@ -621,8 +609,8 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
                 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)));
-            pendingUpdates.forEach(({ snapId, oldVersion })=>this.messagingSystem.publish(`SnapController:snapUpdated`, this.getTruncatedExpect(snapId), oldVersion));
+            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)=>_class_private_field_get(this, _rollbackSnapshots).delete(snapId));
         } catch (error) {
             const installed = pendingInstalls.filter((snapId)=>this.has(snapId));
@@ -655,7 +643,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
             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 necesary as installSnaps may be installing multiple snaps
+            // This is necessary as installSnaps may be installing multiple snaps
             // and we don't want to emit events prematurely.
             false);
         }
@@ -735,23 +723,25 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         try {
             const snap = this.getExpect(snapId);
             const newSnap = await _class_private_method_get(this, _fetchSnap, fetchSnap).call(this, snapId, location);
-            const newVersion = newSnap.manifest.result.version;
+            const { sourceCode: sourceCodeFile, manifest: manifestFile } = newSnap.files;
+            const manifest = manifestFile.result;
+            const newVersion = manifest.version;
             if (!gtVersion(newVersion, snap.version)) {
-                throw ethErrors.rpc.invalidParams(`Snap "${snapId}@${snap.version}" is already installed. Couldn't update to a version inside requested "${newVersionRange}" range.`);
+                throw rpcErrors.invalidParams(`Snap "${snapId}@${snap.version}" is already installed. Couldn't update to a version inside requested "${newVersionRange}" range.`);
             }
             if (!satisfiesVersionRange(newVersion, newVersionRange)) {
                 throw new Error(`Version mismatch. Manifest for "${snapId}" specifies version "${newVersion}" which doesn't satisfy requested version range "${newVersionRange}".`);
             }
             await _class_private_method_get(this, _assertIsInstallAllowed, assertIsInstallAllowed).call(this, snapId, {
                 version: newVersion,
-                checksum: newSnap.manifest.result.source.shasum
+                checksum: manifest.source.shasum
             });
-            const processedPermissions = processSnapPermissions(newSnap.manifest.result.initialPermissions);
+            const processedPermissions = 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, {
                 permissions: newPermissions,
-                newVersion: newSnap.manifest.result.version,
+                newVersion: manifest.version,
                 newPermissions,
                 approvedPermissions,
                 unusedPermissions,
@@ -770,7 +760,6 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
             _class_private_method_get(this, _set, set).call(this, {
                 origin,
                 id: snapId,
-                manifest: newSnap.manifest,
                 files: newSnap.files,
                 isUpdate: true
             });
@@ -795,8 +784,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
                 rollbackSnapshot.permissions.granted = Object.keys(approvedNewPermissions);
                 rollbackSnapshot.permissions.requestData = requestData;
             }
-            const normalizedSourcePath = normalizeRelative(newSnap.manifest.result.source.location.npm.filePath);
-            const sourceCode = newSnap.files.find((file)=>file.path === normalizedSourcePath)?.toString();
+            const sourceCode = sourceCodeFile.toString();
             assert(typeof sourceCode === 'string' && sourceCode.length > 0, `Invalid source code for snap "${snapId}".`);
             try {
                 await _class_private_method_get(this, _startSnap, startSnap).call(this, {
@@ -808,7 +796,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
             }
             const truncatedSnap = this.getTruncatedExpect(snapId);
             if (emitEvent) {
-                this.messagingSystem.publish('SnapController:snapUpdated', truncatedSnap, snap.version);
+                this.messagingSystem.publish('SnapController:snapUpdated', truncatedSnap, snap.version, origin);
             }
             _class_private_method_get(this, _updateApproval, updateApproval).call(this, pendingApproval.id, {
                 loading: false,
@@ -878,6 +866,8 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         /* 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.
@@ -927,17 +917,15 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         super({
             messenger,
             metadata: {
-                snapErrors: {
-                    persist: false,
-                    anonymous: false
-                },
                 snapStates: {
                     persist: true,
                     anonymous: false
                 },
                 snaps: {
                     persist: (snaps)=>{
-                        return Object.values(snaps).map((snap)=>{
+                        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 !== SnapStatus.Installing).map((snap)=>{
                             return {
                                 ...snap,
                                 // At the time state is rehydrated, no snap will be running.
@@ -980,6 +968,7 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         _class_private_method_init(this, _revokeAllSnapPermissions);
         _class_private_method_init(this, _createApproval);
         _class_private_method_init(this, _updateApproval);
+        _class_private_method_init(this, _resolveAllowlistVersion);
         /**
    * 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.
@@ -1005,8 +994,6 @@ _initializeStateMachine = /*#__PURE__*/ new WeakSet(), /**
         /**
    * Fetches the manifest and source code of a snap.
    *
-   * This function is not hash private yet because of tests.
-   *
    * @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.
@@ -1215,13 +1202,13 @@ function registerMessageHandlers() {
     this.messagingSystem.registerActionHandler(`${controllerName}:remove`, async (...args)=>this.removeSnap(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:getPermitted`, (...args)=>this.getPermittedSnaps(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:install`, async (...args)=>this.installSnaps(...args));
-    this.messagingSystem.registerActionHandler(`${controllerName}:removeSnapError`, (...args)=>this.removeSnapError(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:getAll`, (...args)=>this.getAllSnaps(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:incrementActiveReferences`, (...args)=>this.incrementActiveReferences(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:decrementActiveReferences`, (...args)=>this.decrementActiveReferences(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:getRegistryMetadata`, async (...args)=>this.getRegistryMetadata(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:disconnectOrigin`, (...args)=>this.removeSnapFromSubject(...args));
     this.messagingSystem.registerActionHandler(`${controllerName}:revokeDynamicPermissions`, (...args)=>this.revokeDynamicSnapPermissions(...args));
+    this.messagingSystem.registerActionHandler(`${controllerName}:getFile`, (...args)=>this.getSnapFile(...args));
 }
 function pollForLastRequestStatus() {
     _class_private_field_set(this, _timeoutForLastRequestStatus, setTimeout(()=>{
@@ -1265,7 +1252,7 @@ async function assertIsInstallAllowed(snapId, snapInfo) {
     if (result.status === 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 !== SnapsRegistryStatus.Verified) {
-        throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": The snap is not on the allow list.`);
+        throw new Error(`Cannot install version "${snapInfo.version}" of snap "${snapId}": The snap is not on the allowlist.`);
     }
 }
 async function stopSnapsLastRequestPastMax() {
@@ -1331,6 +1318,9 @@ function updateApproval(id, requestState) {
     // Do nothing
     }
 }
+async function resolveAllowlistVersion(snapId, versionRange) {
+    return await this.messagingSystem.call('SnapsRegistry:resolveVersion', snapId, versionRange);
+}
 async function add(args) {
     const { id: snapId, location, versionRange } = args;
     _class_private_method_get(this, _setupRuntime, setupRuntime).call(this, snapId, {
@@ -1344,7 +1334,7 @@ async function add(args) {
         // 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.manifest.result;
+            const manifest = fetchedSnap.files.manifest.result;
             if (!satisfiesVersionRange(manifest.version, versionRange)) {
                 throw new Error(`Version mismatch. Manifest for "${snapId}" specifies version "${manifest.version}" which doesn't satisfy requested version range "${versionRange}".`);
             }
@@ -1414,15 +1404,16 @@ async function getEndowments(snapId) {
     return dedupedEndowments;
 }
 function set(args) {
-    const { id: snapId, origin, manifest, files, isUpdate = false } = args;
+    const { id: snapId, origin, files, isUpdate = false } = args;
+    const { manifest, sourceCode: sourceCodeFile, svgIcon, auxiliaryFiles: rawAuxiliaryFiles } = files;
     assertIsSnapManifest(manifest.result);
     const { version } = manifest.result;
-    const normalizedSourcePath = normalizeRelative(manifest.result.source.location.npm.filePath);
-    const { iconPath } = manifest.result.source.location.npm;
-    const normalizedIconPath = iconPath && normalizeRelative(iconPath);
-    const sourceCode = files.find((file)=>file.path === normalizedSourcePath)?.toString();
-    const svgIcon = normalizedIconPath ? files.find((file)=>file.path === normalizedIconPath) : undefined;
+    const sourceCode = sourceCodeFile.toString();
     assert(typeof sourceCode === 'string' && sourceCode.length > 0, `Invalid source code for snap "${snapId}".`);
+    const auxiliaryFiles = rawAuxiliaryFiles.map((file)=>({
+            path: file.path,
+            value: file.toString('base64')
+        }));
     const snapsState = this.state.snaps;
     const existingSnap = snapsState[snapId];
     const previousVersionHistory = existingSnap?.versionHistory ?? [];
@@ -1447,7 +1438,8 @@ function set(args) {
         status: _class_private_field_get(this, _statusMachine).config.initial,
         sourceCode,
         version,
-        versionHistory
+        versionHistory,
+        auxiliaryFiles
     };
     // If the snap was blocked, it isn't any longer
     delete snap.blockInformation;
@@ -1475,19 +1467,15 @@ async function fetchSnap(snapId, location) {
         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 files = [
-            sourceCode
-        ];
-        if (svgIcon) {
-            files.push(svgIcon);
-        }
-        validateFetchedSnap({
+        const auxiliaryFiles = manifest.result.source.files ? await Promise.all(manifest.result.source.files.map(async (filePath)=>location.fetch(filePath))) : [];
+        const files = {
             manifest,
             sourceCode,
-            svgIcon
-        });
+            svgIcon,
+            auxiliaryFiles
+        };
+        validateFetchedSnap(files);
         return {
-            manifest,
             files,
             location
         };
@@ -1556,8 +1544,11 @@ function getRpcRequestHandler(snapId) {
             _class_private_method_get(this, _recordSnapRpcRequestFinish, recordSnapRpcRequestFinish).call(this, snapId, request.id);
             return result;
         } catch (error) {
-            await this.stopSnap(snapId, SnapStatusEvents.Crash);
-            throw error;
+            const [jsonRpcError, handled] = unwrapError(error);
+            if (!handled) {
+                await this.stopSnap(snapId, SnapStatusEvents.Crash);
+            }
+            throw jsonRpcError;
         }
     };
     runtime.rpcHandler = rpcHandler;