@metamask/permission-controller 3.2.0 → 4.0.0

package/dist/PermissionController.js

@@ -24,17 +24,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PermissionController = exports.CaveatMutatorOperation = void 0;
+/* eslint-enable @typescript-eslint/no-unused-vars */
 const deep_freeze_strict_1 = __importDefault(require("deep-freeze-strict"));
 const immer_1 = require("immer");
 const nanoid_1 = require("nanoid");
 const eth_rpc_errors_1 = require("eth-rpc-errors");
+const utils_1 = require("@metamask/utils");
 const base_controller_1 = require("@metamask/base-controller");
 const controller_utils_1 = require("@metamask/controller-utils");
 const Caveat_1 = require("./Caveat");
 const errors_1 = require("./errors");
 const Permission_1 = require("./Permission");
 const permission_middleware_1 = require("./permission-middleware");
-const utils_1 = require("./utils");
+const utils_2 = require("./utils");
 /**
  * The name of the {@link PermissionController}.
  */
@@ -128,11 +130,11 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
     /**
      * Gets a permission specification.
      *
-     * @param targetKey - The target key of the permission specification to get.
-     * @returns The permission specification with the specified target key.
+     * @param targetName - The name of the permission specification to get.
+     * @returns The permission specification with the specified target name.
      */
-    getPermissionSpecification(targetKey) {
-        return this._permissionSpecifications[targetKey];
+    getPermissionSpecification(targetName) {
+        return this._permissionSpecifications[targetName];
     }
     /**
      * Gets a caveat specification.
@@ -144,9 +146,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         return this._caveatSpecifications[caveatType];
     }
     /**
-     * Constructor helper for validating permission specifications. This is
-     * intended to prevent the use of invalid target keys which, while impossible
-     * to add in TypeScript, could rather easily occur in plain JavaScript.
+     * Constructor helper for validating permission specifications.
      *
      * Throws an error if validation fails.
      *
@@ -156,21 +156,19 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
      * controller.
      */
     validatePermissionSpecifications(permissionSpecifications, caveatSpecifications) {
-        Object.entries(permissionSpecifications).forEach(([targetKey, { permissionType, targetKey: innerTargetKey, allowedCaveats },]) => {
-            if (!permissionType || !(0, controller_utils_1.hasProperty)(Permission_1.PermissionType, permissionType)) {
+        Object.entries(permissionSpecifications).forEach(([targetName, { permissionType, targetName: innerTargetName, allowedCaveats },]) => {
+            if (!permissionType || !(0, utils_1.hasProperty)(Permission_1.PermissionType, permissionType)) {
                 throw new Error(`Invalid permission type: "${permissionType}"`);
             }
-            // Check if the target key is the empty string, ends with "_", or ends
-            // with "*" but not "_*"
-            if (!targetKey || /_$/u.test(targetKey) || /[^_]\*$/u.test(targetKey)) {
-                throw new Error(`Invalid permission target key: "${targetKey}"`);
+            if (!targetName) {
+                throw new Error(`Invalid permission target name: "${targetName}"`);
             }
-            if (targetKey !== innerTargetKey) {
-                throw new Error(`Invalid permission specification: key "${targetKey}" must match specification.target value "${innerTargetKey}".`);
+            if (targetName !== innerTargetName) {
+                throw new Error(`Invalid permission specification: target name "${targetName}" must match specification.targetName value "${innerTargetName}".`);
             }
             if (allowedCaveats) {
                 allowedCaveats.forEach((caveatType) => {
-                    if (!(0, controller_utils_1.hasProperty)(caveatSpecifications, caveatType)) {
+                    if (!(0, utils_1.hasProperty)(caveatSpecifications, caveatType)) {
                         throw new errors_1.UnrecognizedCaveatTypeError(caveatType);
                     }
                     const specification = caveatSpecifications[caveatType];
@@ -231,11 +229,10 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         const failureError = permissionType === Permission_1.PermissionType.RestrictedMethod
             ? (0, errors_1.methodNotFound)(targetName, requestingOrigin ? { origin: requestingOrigin } : undefined)
             : new errors_1.EndowmentPermissionDoesNotExistError(targetName, requestingOrigin);
-        const targetKey = this.getTargetKey(targetName);
-        if (!targetKey) {
+        if (!this.targetExists(targetName)) {
             throw failureError;
         }
-        const specification = this.getPermissionSpecification(targetKey);
+        const specification = this.getPermissionSpecification(targetName);
         if (!(0, Permission_1.hasSpecificationType)(specification, permissionType)) {
             throw failureError;
         }
@@ -346,12 +343,12 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
     revokePermissions(subjectsAndPermissions) {
         this.update((draftState) => {
             Object.keys(subjectsAndPermissions).forEach((origin) => {
-                if (!(0, controller_utils_1.hasProperty)(draftState.subjects, origin)) {
+                if (!(0, utils_1.hasProperty)(draftState.subjects, origin)) {
                     throw new errors_1.UnrecognizedSubjectError(origin);
                 }
                 subjectsAndPermissions[origin].forEach((target) => {
                     const { permissions } = draftState.subjects[origin];
-                    if (!(0, controller_utils_1.hasProperty)(permissions, target)) {
+                    if (!(0, utils_1.hasProperty)(permissions, target)) {
                         throw new errors_1.PermissionDoesNotExistError(origin, target);
                     }
                     this.deletePermission(draftState.subjects, origin, target);
@@ -372,7 +369,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         this.update((draftState) => {
             Object.entries(draftState.subjects).forEach(([origin, subject]) => {
                 const { permissions } = subject;
-                if ((0, controller_utils_1.hasProperty)(permissions, target)) {
+                if ((0, utils_1.hasProperty)(permissions, target)) {
                     this.deletePermission(draftState.subjects, origin, target);
                 }
             });
@@ -539,7 +536,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
                 // If all else fails, the permission validator is also called.
                 permission.caveats = [caveat];
             }
-            this.validateModifiedPermission(permission, origin, target);
+            this.validateModifiedPermission(permission, origin);
         });
     }
     /**
@@ -594,7 +591,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
                             this.validateCaveat(targetCaveat, subject.origin, permission.parentCapability);
                             break;
                         case CaveatMutatorOperation.deleteCaveat:
-                            this.deleteCaveat(permission, targetCaveatType, subject.origin, permission.parentCapability);
+                            this.deleteCaveat(permission, targetCaveatType, subject.origin);
                             break;
                         case CaveatMutatorOperation.revokePermission:
                             this.deletePermission(draftState.subjects, subject.origin, permission.parentCapability);
@@ -633,7 +630,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
             if (!permission.caveats) {
                 throw new errors_1.CaveatDoesNotExistError(origin, target, caveatType);
             }
-            this.deleteCaveat(permission, caveatType, origin, target);
+            this.deleteCaveat(permission, caveatType, origin);
         });
     }
     /**
@@ -647,16 +644,15 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
      * @param permission - The permission whose caveat to delete.
      * @param caveatType - The type of the caveat to delete.
      * @param origin - The origin the permission subject.
-     * @param target - The name of the permission target.
      */
-    deleteCaveat(permission, caveatType, origin, target) {
+    deleteCaveat(permission, caveatType, origin) {
         /* istanbul ignore if: not possible in our usage */
         if (!permission.caveats) {
-            throw new errors_1.CaveatDoesNotExistError(origin, target, caveatType);
+            throw new errors_1.CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
         }
         const caveatIndex = permission.caveats.findIndex((existingCaveat) => existingCaveat.type === caveatType);
         if (caveatIndex === -1) {
-            throw new errors_1.CaveatDoesNotExistError(origin, target, caveatType);
+            throw new errors_1.CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
         }
         if (permission.caveats.length === 1) {
             permission.caveats = null;
@@ -664,62 +660,35 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         else {
             permission.caveats.splice(caveatIndex, 1);
         }
-        this.validateModifiedPermission(permission, origin, target);
+        this.validateModifiedPermission(permission, origin);
     }
     /**
      * Validates the specified modified permission. Should **always** be invoked
      * on a permission after its caveats have been modified.
      *
      * Just like {@link PermissionController.validatePermission}, except that the
-     * corresponding target key and specification are retrieved first, and an
-     * error is thrown if the target key does not exist.
+     * corresponding target name and specification are retrieved first, and an
+     * error is thrown if the target name does not exist.
      *
      * @param permission - The modified permission to validate.
      * @param origin - The origin associated with the permission.
-     * @param targetName - The target name name of the permission.
      */
-    validateModifiedPermission(permission, origin, targetName) {
-        const targetKey = this.getTargetKey(permission.parentCapability);
+    validateModifiedPermission(permission, origin) {
         /* istanbul ignore if: this should be impossible */
-        if (!targetKey) {
-            throw new Error(`Fatal: Existing permission target key "${targetKey}" has no specification.`);
+        if (!this.targetExists(permission.parentCapability)) {
+            throw new Error(`Fatal: Existing permission target "${permission.parentCapability}" has no specification.`);
         }
-        this.validatePermission(this.getPermissionSpecification(targetKey), permission, origin, targetName);
+        this.validatePermission(this.getPermissionSpecification(permission.parentCapability), permission, origin);
     }
     /**
-     * Gets the key for the specified permission target.
-     *
-     * Used to support our namespaced permission target feature, which is used
-     * to implement namespaced restricted JSON-RPC methods.
+     * Verifies the existence the specified permission target, i.e. whether it has
+     * a specification.
      *
      * @param target - The requested permission target.
-     * @returns The internal key of the permission target.
+     * @returns Whether the permission target exists.
      */
-    getTargetKey(target) {
-        if ((0, controller_utils_1.hasProperty)(this._permissionSpecifications, target)) {
-            return target;
-        }
-        const namespacedTargetsWithoutWildcard = {};
-        for (const targetKey of Object.keys(this._permissionSpecifications)) {
-            const wildCardMatch = targetKey.match(/(.+)\*$/u);
-            if (wildCardMatch) {
-                namespacedTargetsWithoutWildcard[wildCardMatch[1]] = true;
-            }
-        }
-        // Check for potentially nested namespaces:
-        // Ex: wildzone_
-        // Ex: eth_plugin_
-        const segments = target.split('_');
-        let targetKey = '';
-        while (segments.length > 0 &&
-            !(0, controller_utils_1.hasProperty)(this._permissionSpecifications, targetKey) &&
-            !namespacedTargetsWithoutWildcard[targetKey]) {
-            targetKey += `${segments.shift()}_`;
-        }
-        if (namespacedTargetsWithoutWildcard[targetKey]) {
-            return `${targetKey}*`;
-        }
-        return undefined;
+    targetExists(target) {
+        return (0, utils_1.hasProperty)(this._permissionSpecifications, target);
     }
     /**
      * Grants _approved_ permissions to the specified subject. Every permission and
@@ -748,18 +717,17 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         const permissions = (preserveExistingPermissions
             ? Object.assign({}, this.getPermissions(origin)) : {});
         for (const [requestedTarget, approvedPermission] of Object.entries(approvedPermissions)) {
-            const targetKey = this.getTargetKey(requestedTarget);
-            if (!targetKey) {
+            if (!this.targetExists(requestedTarget)) {
                 throw (0, errors_1.methodNotFound)(requestedTarget);
             }
             if (approvedPermission.parentCapability !== undefined &&
                 requestedTarget !== approvedPermission.parentCapability) {
                 throw new errors_1.InvalidApprovedPermissionError(origin, requestedTarget, approvedPermission);
             }
-            // The requested target must be a valid target name if we found its key.
-            // We reassign it to change its type.
+            // We have verified that the target exists, and reassign it to change its
+            // type.
             const targetName = requestedTarget;
-            const specification = this.getPermissionSpecification(targetKey);
+            const specification = this.getPermissionSpecification(targetName);
             // The requested caveats are validated here.
             const caveats = this.constructCaveats(origin, targetName, approvedPermission.caveats);
             const permissionOptions = {
@@ -773,14 +741,14 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
                 // Full caveat and permission validation is performed here since the
                 // factory function can arbitrarily modify the entire permission object,
                 // including its caveats.
-                this.validatePermission(specification, permission, origin, targetName);
+                this.validatePermission(specification, permission, origin);
             }
             else {
                 permission = (0, Permission_1.constructPermission)(permissionOptions);
                 // We do not need to validate caveats in this case, because the plain
                 // permission constructor function does not modify the caveats, which
                 // were already validated by `constructCaveats` above.
-                this.validatePermission(specification, permission, origin, targetName, {
+                this.validatePermission(specification, permission, origin, {
                     invokePermissionValidator: true,
                     performCaveatValidation: false,
                 });
@@ -804,7 +772,6 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
      * @param specification - The specification of the permission.
      * @param permission - The permission to validate.
      * @param origin - The origin associated with the permission.
-     * @param targetName - The target name of the permission.
      * @param validationOptions - Validation options.
      * @param validationOptions.invokePermissionValidator - Whether to invoke the
      * permission's consumer-specified validator function, if any.
@@ -812,12 +779,12 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
      * {@link PermissionController.validateCaveat} on each of the permission's
      * caveats.
      */
-    validatePermission(specification, permission, origin, targetName, { invokePermissionValidator, performCaveatValidation } = {
+    validatePermission(specification, permission, origin, { invokePermissionValidator, performCaveatValidation } = {
         invokePermissionValidator: true,
         performCaveatValidation: true,
     }) {
         var _a;
-        const { allowedCaveats, validator } = specification;
+        const { allowedCaveats, validator, targetName } = specification;
         if (((_a = specification.subjectTypes) === null || _a === void 0 ? void 0 : _a.length) &&
             specification.subjectTypes.length > 0) {
             const metadata = this.messagingSystem.call('SubjectMetadataController:getSubjectMetadata', origin);
@@ -829,7 +796,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
                     : new errors_1.EndowmentPermissionDoesNotExistError(targetName, origin);
             }
         }
-        if ((0, controller_utils_1.hasProperty)(permission, 'caveats')) {
+        if ((0, utils_1.hasProperty)(permission, 'caveats')) {
             const { caveats } = permission;
             if (caveats !== null && !(Array.isArray(caveats) && caveats.length > 0)) {
                 throw new errors_1.InvalidCaveatsPropertyError(origin, targetName, caveats);
@@ -920,7 +887,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         if (!specification) {
             throw new errors_1.UnrecognizedCaveatTypeError(caveat.type, origin, target);
         }
-        if (!(0, controller_utils_1.hasProperty)(caveat, 'value') || caveat.value === undefined) {
+        if (!(0, utils_1.hasProperty)(caveat, 'value') || caveat.value === undefined) {
             throw new errors_1.CaveatMissingValueError(caveat, origin, target);
         }
         if (!(0, controller_utils_1.isValidJson)(caveat.value)) {
@@ -1021,8 +988,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
         }
         for (const targetName of Object.keys(requestedPermissions)) {
             const permission = requestedPermissions[targetName];
-            const targetKey = this.getTargetKey(targetName);
-            if (!targetKey) {
+            if (!this.targetExists(targetName)) {
                 throw (0, errors_1.methodNotFound)(targetName, { origin, requestedPermissions });
             }
             if (!(0, controller_utils_1.isPlainObject)(permission) ||
@@ -1035,9 +1001,9 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
             }
             // Here we validate the permission without invoking its validator, if any.
             // The validator will be invoked after the permission has been approved.
-            this.validatePermission(this.getPermissionSpecification(targetKey), 
+            this.validatePermission(this.getPermissionSpecification(targetName), 
             // Typecast: The permission is still a "PlainObject" here.
-            permission, origin, targetName, { invokePermissionValidator: false, performCaveatValidation: true });
+            permission, origin, { invokePermissionValidator: false, performCaveatValidation: true });
         }
     }
     /**
@@ -1055,7 +1021,7 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
                 id,
                 origin,
                 requestData: permissionsRequest,
-                type: utils_1.MethodNames.requestPermissions,
+                type: utils_2.MethodNames.requestPermissions,
             }, true);
             this.validateApprovedPermissions(approvedRequest, { id, origin });
             return approvedRequest;
@@ -1069,9 +1035,8 @@ class PermissionController extends base_controller_1.BaseControllerV2 {
      */
     getSideEffects(permissions) {
         return Object.keys(permissions).reduce((sideEffectList, targetName) => {
-            const targetKey = this.getTargetKey(targetName);
-            if (targetKey) {
-                const specification = this.getPermissionSpecification(targetKey);
+            if (this.targetExists(targetName)) {
+                const specification = this.getPermissionSpecification(targetName);
                 if (specification.sideEffect) {
                     sideEffectList.permittedHandlers[targetName] =
                         specification.sideEffect.onPermitted;