@metamask/permission-controller 12.1.1 → 12.2.1

package/dist/PermissionController.mjs

@@ -3,7 +3,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PermissionController_instances, _PermissionController_expectGetCaveatMerger, _PermissionController_applyGrantedPermissions, _PermissionController_mergeIncrementalPermissions, _PermissionController_mergePermission, _PermissionController_mergeCaveat, _PermissionController_handleApprovedPermissions;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _PermissionController_instances, _PermissionController_caveatSpecifications, _PermissionController_permissionSpecifications, _PermissionController_unrestrictedMethods, _PermissionController_getPermissionSpecification, _PermissionController_getCaveatSpecification, _PermissionController_expectGetCaveatMerger, _PermissionController_validatePermissionSpecifications, _PermissionController_registerMessageHandlers, _PermissionController_getTypedPermissionSpecification, _PermissionController_deletePermission, _PermissionController_setCaveat, _PermissionController_deleteCaveat, _PermissionController_validateModifiedPermission, _PermissionController_targetExists, _PermissionController_applyGrantedPermissions, _PermissionController_validatePermission, _PermissionController_setValidatedPermissions, _PermissionController_constructCaveats, _PermissionController_validateCaveat, _PermissionController_validateRequestedPermissions, _PermissionController_mergeIncrementalPermissions, _PermissionController_mergePermission, _PermissionController_mergeCaveat, _PermissionController_requestUserApproval, _PermissionController_handleApprovedPermissions, _PermissionController_getSideEffects, _PermissionController_executeSideEffects, _PermissionController_validateApprovedPermissions, _PermissionController_hasApprovalRequest, _PermissionController_rejectPermissionsRequest, _PermissionController_executeRestrictedMethod;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -82,7 +88,7 @@ export class PermissionController extends BaseController {
      * @returns The names of all unrestricted JSON-RPC methods
      */
     get unrestrictedMethods() {
-        return this._unrestrictedMethods;
+        return __classPrivateFieldGet(this, _PermissionController_unrestrictedMethods, "f");
     }
     /**
      * Constructs the PermissionController.
@@ -113,96 +119,22 @@ export class PermissionController extends BaseController {
             },
         });
         _PermissionController_instances.add(this);
-        this._unrestrictedMethods = new Set(unrestrictedMethods);
-        this._caveatSpecifications = deepFreeze({ ...caveatSpecifications });
-        this.validatePermissionSpecifications(permissionSpecifications, this._caveatSpecifications);
-        this._permissionSpecifications = deepFreeze({
+        _PermissionController_caveatSpecifications.set(this, void 0);
+        _PermissionController_permissionSpecifications.set(this, void 0);
+        _PermissionController_unrestrictedMethods.set(this, void 0);
+        __classPrivateFieldSet(this, _PermissionController_unrestrictedMethods, new Set(unrestrictedMethods), "f");
+        __classPrivateFieldSet(this, _PermissionController_caveatSpecifications, deepFreeze({ ...caveatSpecifications }), "f");
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validatePermissionSpecifications).call(this, permissionSpecifications, __classPrivateFieldGet(this, _PermissionController_caveatSpecifications, "f"));
+        __classPrivateFieldSet(this, _PermissionController_permissionSpecifications, deepFreeze({
             ...permissionSpecifications,
-        });
-        this.registerMessageHandlers();
+        }), "f");
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_registerMessageHandlers).call(this);
         this.createPermissionMiddleware = getPermissionMiddlewareFactory({
-            executeRestrictedMethod: this._executeRestrictedMethod.bind(this),
+            executeRestrictedMethod: __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_executeRestrictedMethod).bind(this),
             getRestrictedMethod: this.getRestrictedMethod.bind(this),
             isUnrestrictedMethod: this.unrestrictedMethods.has.bind(this.unrestrictedMethods),
         });
     }
-    /**
-     * Gets a permission specification.
-     *
-     * @param targetName - The name of the permission specification to get.
-     * @returns The permission specification with the specified target name.
-     */
-    getPermissionSpecification(targetName) {
-        return this._permissionSpecifications[targetName];
-    }
-    /**
-     * Gets a caveat specification.
-     *
-     * @param caveatType - The type of the caveat specification to get.
-     * @returns The caveat specification with the specified type.
-     */
-    getCaveatSpecification(caveatType) {
-        return this._caveatSpecifications[caveatType];
-    }
-    /**
-     * Constructor helper for validating permission specifications.
-     *
-     * Throws an error if validation fails.
-     *
-     * @param permissionSpecifications - The permission specifications passed to
-     * this controller's constructor.
-     * @param caveatSpecifications - The caveat specifications passed to this
-     * controller.
-     */
-    validatePermissionSpecifications(permissionSpecifications, caveatSpecifications) {
-        Object.entries(permissionSpecifications).forEach(([targetName, { permissionType, targetName: innerTargetName, allowedCaveats },]) => {
-            if (!permissionType || !hasProperty(PermissionType, permissionType)) {
-                throw new Error(`Invalid permission type: "${permissionType}"`);
-            }
-            if (!targetName) {
-                throw new Error(`Invalid permission target name: "${targetName}"`);
-            }
-            if (targetName !== innerTargetName) {
-                throw new Error(`Invalid permission specification: target name "${targetName}" must match specification.targetName value "${innerTargetName}".`);
-            }
-            if (allowedCaveats) {
-                allowedCaveats.forEach((caveatType) => {
-                    if (!hasProperty(caveatSpecifications, caveatType)) {
-                        throw new UnrecognizedCaveatTypeError(caveatType);
-                    }
-                    const specification = caveatSpecifications[caveatType];
-                    const isRestrictedMethodCaveat = isRestrictedMethodCaveatSpecification(specification);
-                    if ((permissionType === PermissionType.RestrictedMethod &&
-                        !isRestrictedMethodCaveat) ||
-                        (permissionType === PermissionType.Endowment &&
-                            isRestrictedMethodCaveat)) {
-                        throw new CaveatSpecificationMismatchError(specification, permissionType);
-                    }
-                });
-            }
-        });
-    }
-    /**
-     * Constructor helper for registering the controller's messenger actions.
-     */
-    registerMessageHandlers() {
-        this.messenger.registerActionHandler(`${controllerName}:clearPermissions`, () => this.clearState());
-        this.messenger.registerActionHandler(`${controllerName}:getEndowments`, (origin, targetName, requestData) => this.getEndowments(origin, targetName, requestData));
-        this.messenger.registerActionHandler(`${controllerName}:getSubjectNames`, () => this.getSubjectNames());
-        this.messenger.registerActionHandler(`${controllerName}:getPermissions`, (origin) => this.getPermissions(origin));
-        this.messenger.registerActionHandler(`${controllerName}:hasPermission`, (origin, targetName) => this.hasPermission(origin, targetName));
-        this.messenger.registerActionHandler(`${controllerName}:hasPermissions`, (origin) => this.hasPermissions(origin));
-        this.messenger.registerActionHandler(`${controllerName}:grantPermissions`, this.grantPermissions.bind(this));
-        this.messenger.registerActionHandler(`${controllerName}:grantPermissionsIncremental`, this.grantPermissionsIncremental.bind(this));
-        this.messenger.registerActionHandler(`${controllerName}:requestPermissions`, (subject, permissions) => this.requestPermissions(subject, permissions));
-        this.messenger.registerActionHandler(`${controllerName}:requestPermissionsIncremental`, (subject, permissions) => this.requestPermissionsIncremental(subject, permissions));
-        this.messenger.registerActionHandler(`${controllerName}:revokeAllPermissions`, (origin) => this.revokeAllPermissions(origin));
-        this.messenger.registerActionHandler(`${controllerName}:revokePermissionForAllSubjects`, (target) => this.revokePermissionForAllSubjects(target));
-        this.messenger.registerActionHandler(`${controllerName}:revokePermissions`, this.revokePermissions.bind(this));
-        this.messenger.registerActionHandler(`${controllerName}:updateCaveat`, (origin, target, caveatType, caveatValue) => {
-            this.updateCaveat(origin, target, caveatType, caveatValue);
-        });
-    }
     /**
      * Clears the state of the controller.
      */
@@ -213,33 +145,6 @@ export class PermissionController extends BaseController {
             };
         });
     }
-    /**
-     * Gets the permission specification corresponding to the given permission
-     * type and target name. Throws an error if the target name does not
-     * correspond to a permission, or if the specification is not of the
-     * given permission type.
-     *
-     * @template Type - The type of the permission specification to get.
-     * @param permissionType - The type of the permission specification to get.
-     * @param targetName - The name of the permission whose specification to get.
-     * @param requestingOrigin - The origin of the requesting subject, if any.
-     * Will be added to any thrown errors.
-     * @returns The specification object corresponding to the given type and
-     * target name.
-     */
-    getTypedPermissionSpecification(permissionType, targetName, requestingOrigin) {
-        const failureError = permissionType === PermissionType.RestrictedMethod
-            ? methodNotFound(targetName, requestingOrigin ? { origin: requestingOrigin } : undefined)
-            : new EndowmentPermissionDoesNotExistError(targetName, requestingOrigin);
-        if (!this.targetExists(targetName)) {
-            throw failureError;
-        }
-        const specification = this.getPermissionSpecification(targetName);
-        if (!hasSpecificationType(specification, permissionType)) {
-            throw failureError;
-        }
-        return specification;
-    }
     /**
      * Gets the implementation of the specified restricted method.
      *
@@ -253,7 +158,7 @@ export class PermissionController extends BaseController {
      * @returns The restricted method implementation.
      */
     getRestrictedMethod(method, origin) {
-        return this.getTypedPermissionSpecification(PermissionType.RestrictedMethod, method, origin).methodImplementation;
+        return __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getTypedPermissionSpecification).call(this, PermissionType.RestrictedMethod, method, origin).methodImplementation;
     }
     /**
      * Gets a list of all origins of subjects.
@@ -351,7 +256,7 @@ export class PermissionController extends BaseController {
                     if (!hasProperty(permissions, target)) {
                         throw new PermissionDoesNotExistError(origin, target);
                     }
-                    this.deletePermission(draftState.subjects, origin, target);
+                    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_deletePermission).call(this, draftState.subjects, origin, target);
                 });
             });
         });
@@ -370,30 +275,11 @@ export class PermissionController extends BaseController {
             Object.entries(draftState.subjects).forEach(([origin, subject]) => {
                 const { permissions } = subject;
                 if (hasProperty(permissions, target)) {
-                    this.deletePermission(draftState.subjects, origin, target);
+                    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_deletePermission).call(this, draftState.subjects, origin, target);
                 }
             });
         });
     }
-    /**
-     * Deletes the permission identified by the given origin and target. If the
-     * permission is the single remaining permission of its subject, the subject
-     * is also deleted.
-     *
-     * @param subjects - The draft permission controller subjects.
-     * @param origin - The origin of the subject associated with the permission
-     * to delete.
-     * @param target - The target name of the permission to delete.
-     */
-    deletePermission(subjects, origin, target) {
-        const { permissions } = subjects[origin];
-        if (Object.keys(permissions).length > 1) {
-            delete permissions[target];
-        }
-        else {
-            delete subjects[origin];
-        }
-    }
     /**
      * Checks whether the permission of the subject corresponding to the given
      * origin has a caveat of the specified type.
@@ -457,7 +343,7 @@ export class PermissionController extends BaseController {
         if (this.hasCaveat(origin, target, caveatType)) {
             throw new CaveatAlreadyExistsError(origin, target, caveatType);
         }
-        this.setCaveat(origin, target, caveatType, caveatValue);
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_setCaveat).call(this, origin, target, caveatType, caveatValue);
     }
     /**
      * Updates the value of the caveat of the specified type belonging to the
@@ -481,74 +367,7 @@ export class PermissionController extends BaseController {
         if (!this.hasCaveat(origin, target, caveatType)) {
             throw new CaveatDoesNotExistError(origin, target, caveatType);
         }
-        this.setCaveat(origin, target, caveatType, caveatValue);
-    }
-    /**
-     * Sets the specified caveat on the specified permission. Overwrites existing
-     * caveats of the same type in-place (preserving array order), and adds the
-     * caveat to the end of the array otherwise.
-     *
-     * Throws an error if the permission does not exist or fails to validate after
-     * its caveats have been modified.
-     *
-     * @see {@link PermissionController.addCaveat}
-     * @see {@link PermissionController.updateCaveat}
-     * @template TargetName - The permission target name. Should be inferred.
-     * @template CaveatType - The valid caveat types for the permission. Should
-     * be inferred.
-     * @param origin - The origin of the subject.
-     * @param target - The target name of the permission.
-     * @param caveatType - The type of the caveat to set.
-     * @param caveatValue - The value of the caveat to set.
-     */
-    setCaveat(origin, target, caveatType, caveatValue) {
-        this.update((draftState) => {
-            const subject = draftState.subjects[origin];
-            // Unreachable because `hasCaveat` is always called before this, and it
-            // throws if permissions are missing. TypeScript needs this, however.
-            /* istanbul ignore if */
-            if (!subject) {
-                throw new UnrecognizedSubjectError(origin);
-            }
-            const permission = subject.permissions[target];
-            /* istanbul ignore if: practically impossible, but TypeScript wants it */
-            if (!permission) {
-                throw new PermissionDoesNotExistError(origin, target);
-            }
-            const caveat = {
-                type: caveatType,
-                value: caveatValue,
-            };
-            this.validateCaveat(caveat, origin, target);
-            let addedCaveat = false;
-            if (permission.caveats) {
-                const caveatIndex = permission.caveats.findIndex((existingCaveat) => existingCaveat.type === caveat.type);
-                if (caveatIndex === -1) {
-                    permission.caveats.push(caveat);
-                    addedCaveat = true;
-                }
-                else {
-                    permission.caveats.splice(caveatIndex, 1, caveat);
-                }
-            }
-            else {
-                // At this point, we don't know if the specific permission is allowed
-                // to have caveats, but it should be impossible to call this method
-                // for a permission that may not have any caveats. If all else fails,
-                // the permission validator is also called.
-                // @ts-expect-error See above comment
-                permission.caveats = [caveat];
-                addedCaveat = true;
-            }
-            // Mutating a caveat does not warrant permission validation, but mutating
-            // the caveat array does.
-            if (addedCaveat) {
-                this.validateModifiedPermission(permission, origin, {
-                    invokePermissionValidator: true,
-                    performCaveatValidation: false, // We just validated the caveat
-                });
-            }
-        });
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_setCaveat).call(this, origin, target, caveatType, caveatValue);
     }
     /**
      * Updates all caveats with the specified type for all subjects and
@@ -600,13 +419,13 @@ export class PermissionController extends BaseController {
                             // results in an error.
                             targetCaveat.value =
                                 mutatorResult.value;
-                            this.validateCaveat(targetCaveat, subject.origin, permission.parentCapability);
+                            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateCaveat).call(this, targetCaveat, subject.origin, permission.parentCapability);
                             break;
                         case CaveatMutatorOperation.DeleteCaveat:
-                            this.deleteCaveat(permission, targetCaveatType, subject.origin);
+                            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_deleteCaveat).call(this, permission, targetCaveatType, subject.origin);
                             break;
                         case CaveatMutatorOperation.RevokePermission:
-                            this.deletePermission(draftState.subjects, subject.origin, permission.parentCapability);
+                            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_deletePermission).call(this, draftState.subjects, subject.origin, permission.parentCapability);
                             break;
                         default: {
                             // Overriding as `never` is the expected result of exhaustiveness checking,
@@ -641,70 +460,9 @@ export class PermissionController extends BaseController {
             if (!permission.caveats) {
                 throw new CaveatDoesNotExistError(origin, target, caveatType);
             }
-            this.deleteCaveat(permission, caveatType, origin);
+            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_deleteCaveat).call(this, permission, caveatType, origin);
         });
     }
-    /**
-     * Deletes the specified caveat from the specified permission. If no caveats
-     * remain after deletion, the permission's caveat property is set to `null`.
-     * The permission is validated after being modified.
-     *
-     * Throws an error if the permission does not have a caveat with the specified
-     * type.
-     *
-     * @param permission - The permission whose caveat to delete.
-     * @param caveatType - The type of the caveat to delete.
-     * @param origin - The origin the permission subject.
-     */
-    deleteCaveat(permission, caveatType, origin) {
-        /* istanbul ignore if: not possible in our usage */
-        if (!permission.caveats) {
-            throw new CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
-        }
-        const caveatIndex = permission.caveats.findIndex((existingCaveat) => existingCaveat.type === caveatType);
-        if (caveatIndex === -1) {
-            throw new CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
-        }
-        if (permission.caveats.length === 1) {
-            permission.caveats = null;
-        }
-        else {
-            permission.caveats.splice(caveatIndex, 1);
-        }
-        this.validateModifiedPermission(permission, origin, {
-            invokePermissionValidator: true,
-            performCaveatValidation: false, // No caveat object was mutated
-        });
-    }
-    /**
-     * Validates the specified modified permission. Should **always** be invoked
-     * on a permission when its caveat array has been mutated.
-     *
-     * Just like {@link PermissionController.validatePermission}, except that the
-     * 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 validationFlags - Validation flags. See {@link PermissionController.validatePermission}.
-     */
-    validateModifiedPermission(permission, origin, validationFlags) {
-        /* istanbul ignore if: this should be impossible */
-        if (!this.targetExists(permission.parentCapability)) {
-            throw new Error(`Fatal: Existing permission target "${permission.parentCapability}" has no specification.`);
-        }
-        this.validatePermission(this.getPermissionSpecification(permission.parentCapability), permission, origin, validationFlags);
-    }
-    /**
-     * Verifies the existence the specified permission target, i.e. whether it has
-     * a specification.
-     *
-     * @param target - The requested permission target.
-     * @returns Whether the permission target exists.
-     */
-    targetExists(target) {
-        return hasProperty(this._permissionSpecifications, target);
-    }
     /**
      * Grants _approved_ permissions to the specified subject. Every permission and
      * caveat is stringently validated—including by calling their specification
@@ -761,139 +519,6 @@ export class PermissionController extends BaseController {
             requestData,
         });
     }
-    /**
-     * Validates the specified permission by:
-     * - Ensuring that if `subjectTypes` is specified, the subject requesting the permission is of a type in the list.
-     * - Ensuring that its `caveats` property is either `null` or a non-empty array.
-     * - Ensuring that it only includes caveats allowed by its specification.
-     * - Ensuring that it includes no duplicate caveats (by caveat type).
-     * - Validating each caveat object, if `performCaveatValidation` is `true`.
-     * - Calling the validator of its specification, if one exists and `invokePermissionValidator` is `true`.
-     *
-     * An error is thrown if validation fails.
-     *
-     * @param specification - The specification of the permission.
-     * @param permission - The permission to validate.
-     * @param origin - The origin associated with the permission.
-     * @param validationOptions - Validation options.
-     * @param validationOptions.invokePermissionValidator - Whether to invoke the
-     * permission's consumer-specified validator function, if any.
-     * @param validationOptions.performCaveatValidation - Whether to invoke
-     * {@link PermissionController.validateCaveat} on each of the permission's
-     * caveats.
-     */
-    validatePermission(specification, permission, origin, { invokePermissionValidator, performCaveatValidation, }) {
-        const { allowedCaveats, validator, targetName } = specification;
-        if (specification.subjectTypes?.length &&
-            specification.subjectTypes.length > 0) {
-            const metadata = this.messenger.call('SubjectMetadataController:getSubjectMetadata', origin);
-            if (!metadata ||
-                metadata.subjectType === null ||
-                !specification.subjectTypes.includes(metadata.subjectType)) {
-                throw specification.permissionType === PermissionType.RestrictedMethod
-                    ? methodNotFound(targetName, { origin })
-                    : new EndowmentPermissionDoesNotExistError(targetName, origin);
-            }
-        }
-        if (hasProperty(permission, 'caveats')) {
-            const { caveats } = permission;
-            if (caveats !== null && !(Array.isArray(caveats) && caveats.length > 0)) {
-                throw new InvalidCaveatsPropertyError(origin, targetName, caveats);
-            }
-            const seenCaveatTypes = new Set();
-            caveats?.forEach((caveat) => {
-                if (performCaveatValidation) {
-                    this.validateCaveat(caveat, origin, targetName);
-                }
-                if (!allowedCaveats?.includes(caveat.type)) {
-                    throw new ForbiddenCaveatError(caveat.type, origin, targetName);
-                }
-                if (seenCaveatTypes.has(caveat.type)) {
-                    throw new DuplicateCaveatError(caveat.type, origin, targetName);
-                }
-                seenCaveatTypes.add(caveat.type);
-            });
-        }
-        if (invokePermissionValidator && validator) {
-            validator(permission, origin, targetName);
-        }
-    }
-    /**
-     * Assigns the specified permissions to the subject with the given origin.
-     * Overwrites all existing permissions, and creates a subject entry if it
-     * doesn't already exist.
-     *
-     * ATTN: Assumes that the new permissions have been validated.
-     *
-     * @param origin - The origin of the grantee subject.
-     * @param permissions - The new permissions for the grantee subject.
-     */
-    setValidatedPermissions(origin, permissions) {
-        this.update((draftState) => {
-            if (!draftState.subjects[origin]) {
-                draftState.subjects[origin] = { origin, permissions: {} };
-            }
-            draftState.subjects[origin].permissions = castDraft(permissions);
-        });
-    }
-    /**
-     * Validates the requested caveats for the permission of the specified
-     * subject origin and target name and returns the validated caveat array.
-     *
-     * Throws an error if validation fails.
-     *
-     * @param origin - The origin of the permission subject.
-     * @param target - The permission target name.
-     * @param requestedCaveats - The requested caveats to construct.
-     * @returns The constructed caveats.
-     */
-    constructCaveats(origin, target, requestedCaveats) {
-        const caveatArray = requestedCaveats?.map((requestedCaveat) => {
-            this.validateCaveat(requestedCaveat, origin, target);
-            // Reassign so that we have a fresh object.
-            const { type, value } = requestedCaveat;
-            return { type, value };
-        });
-        return caveatArray && isNonEmptyArray(caveatArray)
-            ? caveatArray
-            : undefined;
-    }
-    /**
-     * This methods validates that the specified caveat is an object with the
-     * expected properties and types. It also ensures that a caveat specification
-     * exists for the requested caveat type, and calls the specification
-     * validator, if it exists, on the caveat object.
-     *
-     * Throws an error if validation fails.
-     *
-     * @param caveat - The caveat object to validate.
-     * @param origin - The origin associated with the subject of the parent
-     * permission.
-     * @param target - The target name associated with the parent permission.
-     */
-    validateCaveat(caveat, origin, target) {
-        if (!isPlainObject(caveat)) {
-            throw new InvalidCaveatError(caveat, origin, target);
-        }
-        if (Object.keys(caveat).length !== 2) {
-            throw new InvalidCaveatFieldsError(caveat, origin, target);
-        }
-        if (typeof caveat.type !== 'string') {
-            throw new InvalidCaveatTypeError(caveat, origin, target);
-        }
-        const specification = this.getCaveatSpecification(caveat.type);
-        if (!specification) {
-            throw new UnrecognizedCaveatTypeError(caveat.type, origin, target);
-        }
-        if (!hasProperty(caveat, 'value') || caveat.value === undefined) {
-            throw new CaveatMissingValueError(caveat, origin, target);
-        }
-        if (!isValidJson(caveat.value)) {
-            throw new CaveatInvalidJsonError(caveat, origin, target);
-        }
-        // Typecast: TypeScript still believes that the caveat is a PlainObject.
-        specification.validator?.(caveat, origin, target);
-    }
     /**
      * Initiates a permission request that requires user approval.
      *
@@ -922,7 +547,7 @@ export class PermissionController extends BaseController {
     async requestPermissions(subject, requestedPermissions, options = {}) {
         const { origin } = subject;
         const { id = nanoid(), preserveExistingPermissions = true } = options;
-        this.validateRequestedPermissions(origin, requestedPermissions);
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateRequestedPermissions).call(this, origin, requestedPermissions);
         const metadata = {
             ...options.metadata,
             id,
@@ -932,7 +557,7 @@ export class PermissionController extends BaseController {
             metadata,
             permissions: requestedPermissions,
         };
-        const approvedRequest = await this.requestUserApproval(permissionsRequest);
+        const approvedRequest = await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_requestUserApproval).call(this, permissionsRequest);
         return await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_handleApprovedPermissions).call(this, {
             subject,
             metadata,
@@ -974,7 +599,7 @@ export class PermissionController extends BaseController {
     async requestPermissionsIncremental(subject, requestedPermissions, options = {}) {
         const { origin } = subject;
         const { id = nanoid() } = options;
-        this.validateRequestedPermissions(origin, requestedPermissions);
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateRequestedPermissions).call(this, origin, requestedPermissions);
         const currentPermissions = this.getPermissions(origin) ?? {};
         const [newPermissions, permissionDiffMap] = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_mergeIncrementalPermissions).call(this, currentPermissions, requestedPermissions);
         // The second undefined check is just for type narrowing purposes. These values
@@ -986,7 +611,7 @@ export class PermissionController extends BaseController {
             // It does not spark joy to run this validation again after the merger operation.
             // But, optimizing this procedure is probably not worth it, especially considering
             // that the worst-case scenario for validation degrades to the below function call.
-            this.validateRequestedPermissions(origin, newPermissions);
+            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateRequestedPermissions).call(this, origin, newPermissions);
         }
         catch (error) {
             if (error instanceof Error) {
@@ -1008,7 +633,7 @@ export class PermissionController extends BaseController {
                 permissionDiffMap,
             },
         };
-        const approvedRequest = await this.requestUserApproval(permissionsRequest);
+        const approvedRequest = await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_requestUserApproval).call(this, permissionsRequest);
         return await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_handleApprovedPermissions).call(this, {
             subject,
             metadata,
@@ -1016,172 +641,6 @@ export class PermissionController extends BaseController {
             approvedRequest,
         });
     }
-    /**
-     * Validates requested permissions. Throws if validation fails.
-     *
-     * This method ensures that the requested permissions are a properly
-     * formatted {@link RequestedPermissions} object, and performs the same
-     * validation as {@link PermissionController.grantPermissions}, except that
-     * consumer-specified permission validator functions are not called, since
-     * they are only called on fully constructed, approved permissions that are
-     * otherwise completely valid.
-     *
-     * Unrecognzied properties on requested permissions are ignored.
-     *
-     * @param origin - The origin of the grantee subject.
-     * @param requestedPermissions - The requested permissions.
-     */
-    validateRequestedPermissions(origin, requestedPermissions) {
-        if (!isPlainObject(requestedPermissions)) {
-            throw invalidParams({
-                message: `Requested permissions for origin "${origin}" is not a plain object.`,
-                data: { origin, requestedPermissions },
-            });
-        }
-        if (Object.keys(requestedPermissions).length === 0) {
-            throw invalidParams({
-                message: `Permissions request for origin "${origin}" contains no permissions.`,
-                data: { requestedPermissions },
-            });
-        }
-        for (const targetName of Object.keys(requestedPermissions)) {
-            const permission = requestedPermissions[targetName];
-            if (!this.targetExists(targetName)) {
-                throw methodNotFound(targetName, { origin, requestedPermissions });
-            }
-            if (!isPlainObject(permission) ||
-                (permission.parentCapability !== undefined &&
-                    targetName !== permission.parentCapability)) {
-                throw invalidParams({
-                    message: `Permissions request for origin "${origin}" contains invalid requested permission(s).`,
-                    data: { origin, requestedPermissions },
-                });
-            }
-            // 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(targetName), 
-            // Typecast: The permission is still a "PlainObject" here.
-            permission, origin, { invokePermissionValidator: false, performCaveatValidation: true });
-        }
-    }
-    /**
-     * Adds a request to the {@link ApprovalController} using the
-     * {@link AddApprovalRequest} action. Also validates the resulting approved
-     * permissions request, and throws an error if validation fails.
-     *
-     * @param permissionsRequest - The permissions request object.
-     * @returns The approved permissions request object.
-     */
-    async requestUserApproval(permissionsRequest) {
-        const { origin, id } = permissionsRequest.metadata;
-        const approvedRequest = await this.messenger.call('ApprovalController:addRequest', {
-            id,
-            origin,
-            requestData: permissionsRequest,
-            type: MethodNames.RequestPermissions,
-        }, true);
-        this.validateApprovedPermissions(approvedRequest, { id, origin });
-        return approvedRequest;
-    }
-    /**
-     * Reunites all the side-effects (onPermitted and onFailure) of the requested permissions inside a record of arrays.
-     *
-     * @param permissions - The approved permissions.
-     * @returns The {@link SideEffects} object containing the handlers arrays.
-     */
-    getSideEffects(permissions) {
-        return Object.keys(permissions).reduce((sideEffectList, targetName) => {
-            if (this.targetExists(targetName)) {
-                const specification = this.getPermissionSpecification(targetName);
-                if (specification.sideEffect) {
-                    sideEffectList.permittedHandlers[targetName] =
-                        specification.sideEffect.onPermitted;
-                    if (specification.sideEffect.onFailure) {
-                        sideEffectList.failureHandlers[targetName] =
-                            specification.sideEffect.onFailure;
-                    }
-                }
-            }
-            return sideEffectList;
-        }, { permittedHandlers: {}, failureHandlers: {} });
-    }
-    /**
-     * Executes the side-effects of the approved permissions while handling the errors if any.
-     * It will pass an instance of the {@link messenger} and the request data associated with the permission request to the handlers through its params.
-     *
-     * @param sideEffects - the side-effect record created by {@link getSideEffects}
-     * @param requestData - the permissions requestData.
-     * @returns the value returned by all the `onPermitted` handlers in an array.
-     */
-    async executeSideEffects(sideEffects, requestData) {
-        const { permittedHandlers, failureHandlers } = sideEffects;
-        const params = {
-            requestData,
-            messenger: this.messenger,
-        };
-        const promiseResults = await Promise.allSettled(Object.values(permittedHandlers).map((permittedHandler) => permittedHandler(params)));
-        // lib.es2020.promise.d.ts does not export its types so we're using a simple type.
-        const rejectedHandlers = promiseResults.filter((promise) => promise.status === 'rejected');
-        if (rejectedHandlers.length > 0) {
-            const failureHandlersList = Object.values(failureHandlers);
-            if (failureHandlersList.length > 0) {
-                try {
-                    await Promise.all(failureHandlersList.map((failureHandler) => failureHandler(params)));
-                }
-                catch (error) {
-                    throw internalError('Unexpected error in side-effects', { error });
-                }
-            }
-            const reasons = rejectedHandlers.map((handler) => handler.reason);
-            reasons.forEach((reason) => {
-                console.error(reason);
-            });
-            throw reasons.length > 1
-                ? internalError('Multiple errors occurred during side-effects execution', { errors: reasons })
-                : reasons[0];
-        }
-        // lib.es2020.promise.d.ts does not export its types so we're using a simple type.
-        return promiseResults.map(({ value }) => value);
-    }
-    /**
-     * Validates an approved {@link PermissionsRequest} object. The approved
-     * request must have the required `metadata` and `permissions` properties,
-     * the `id` and `origin` of the `metadata` must match the original request
-     * metadata, and the requested permissions must be valid per
-     * {@link PermissionController.validateRequestedPermissions}. Any extra
-     * metadata properties are ignored.
-     *
-     * An error is thrown if validation fails.
-     *
-     * @param approvedRequest - The approved permissions request object.
-     * @param originalMetadata - The original request metadata.
-     */
-    validateApprovedPermissions(approvedRequest, originalMetadata) {
-        const { id, origin } = originalMetadata;
-        if (!isPlainObject(approvedRequest) ||
-            !isPlainObject(approvedRequest.metadata)) {
-            throw internalError(`Approved permissions request for subject "${origin}" is invalid.`, { data: { approvedRequest } });
-        }
-        const { metadata: { id: newId, origin: newOrigin }, permissions, } = approvedRequest;
-        if (newId !== id) {
-            throw internalError(`Approved permissions request for subject "${origin}" mutated its id.`, { originalId: id, mutatedId: newId });
-        }
-        if (newOrigin !== origin) {
-            throw internalError(`Approved permissions request for subject "${origin}" mutated its origin.`, { originalOrigin: origin, mutatedOrigin: newOrigin });
-        }
-        try {
-            this.validateRequestedPermissions(origin, permissions);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                // Re-throw as an internal error; we should never receive invalid approved
-                // permissions.
-                throw internalError(`Invalid approved permissions request: ${error.message}`, error instanceof JsonRpcError ? error.data : undefined);
-            }
-            /* istanbul ignore next: This should be impossible */
-            throw internalError('Unrecognized error type', { error });
-        }
-    }
     /**
      * Accepts a permissions request created by
      * {@link PermissionController.requestPermissions}.
@@ -1190,11 +649,11 @@ export class PermissionController extends BaseController {
      */
     async acceptPermissionsRequest(request) {
         const { id } = request.metadata;
-        if (!this.hasApprovalRequest({ id })) {
+        if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_hasApprovalRequest).call(this, { id })) {
             throw new PermissionsRequestNotFoundError(id);
         }
         if (Object.keys(request.permissions).length === 0) {
-            this._rejectPermissionsRequest(id, invalidParams({
+            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_rejectPermissionsRequest).call(this, id, invalidParams({
                 message: 'Must request at least one permission.',
             }));
             return;
@@ -1205,7 +664,7 @@ export class PermissionController extends BaseController {
         catch (error) {
             // If accepting unexpectedly fails, reject the request and re-throw the
             // error
-            this._rejectPermissionsRequest(id, error);
+            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_rejectPermissionsRequest).call(this, id, error);
             throw error;
         }
     }
@@ -1216,37 +675,10 @@ export class PermissionController extends BaseController {
      * @param id - The id of the request to be rejected.
      */
     async rejectPermissionsRequest(id) {
-        if (!this.hasApprovalRequest({ id })) {
+        if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_hasApprovalRequest).call(this, { id })) {
             throw new PermissionsRequestNotFoundError(id);
         }
-        this._rejectPermissionsRequest(id, userRejectedRequest());
-    }
-    /**
-     * Checks whether the {@link ApprovalController} has a particular permissions
-     * request.
-     *
-     * @see {@link PermissionController.acceptPermissionsRequest} and
-     * {@link PermissionController.rejectPermissionsRequest} for usage.
-     * @param options - The {@link HasApprovalRequest} options.
-     * @param options.id - The id of the approval request to check for.
-     * @returns Whether the specified request exists.
-     */
-    hasApprovalRequest(options) {
-        return this.messenger.call('ApprovalController:hasRequest', options);
-    }
-    /**
-     * Rejects the permissions request with the specified id, with the specified
-     * error as the reason. This method is effectively a wrapper around a
-     * messenger call for the `ApprovalController:rejectRequest` action.
-     *
-     * @see {@link PermissionController.acceptPermissionsRequest} and
-     * {@link PermissionController.rejectPermissionsRequest} for usage.
-     * @param id - The id of the request to reject.
-     * @param error - The error associated with the rejection.
-     * @returns Nothing
-     */
-    _rejectPermissionsRequest(id, error) {
-        return this.messenger.call('ApprovalController:rejectRequest', id, error);
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_rejectPermissionsRequest).call(this, id, userRejectedRequest());
     }
     /**
      * Gets the subject's endowments per the specified endowment permission.
@@ -1264,7 +696,7 @@ export class PermissionController extends BaseController {
         if (!this.hasPermission(origin, targetName)) {
             throw unauthorized({ data: { origin, targetName } });
         }
-        return this.getTypedPermissionSpecification(PermissionType.Endowment, targetName, origin).endowmentGetter({ origin, requestData });
+        return __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getTypedPermissionSpecification).call(this, PermissionType.Endowment, targetName, origin).endowmentGetter({ origin, requestData });
     }
     /**
      * Executes a restricted method as the subject with the given origin.
@@ -1294,45 +726,163 @@ export class PermissionController extends BaseController {
     async executeRestrictedMethod(origin, targetName, params) {
         // Throws if the method does not exist
         const methodImplementation = this.getRestrictedMethod(targetName, origin);
-        const result = await this._executeRestrictedMethod(methodImplementation, { origin }, targetName, params);
+        const result = await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_executeRestrictedMethod).call(this, methodImplementation, { origin }, targetName, params);
         if (result === undefined) {
             throw new Error(`Internal request for method "${targetName}" as origin "${origin}" returned no result.`);
         }
         return result;
     }
-    /**
-     * An internal method used in the controller's `json-rpc-engine` middleware
-     * and {@link PermissionController.executeRestrictedMethod}. Calls the
-     * specified restricted method implementation after decorating it with the
-     * caveats of its permission. Throws if the subject does not have the
-     * requisite permission.
-     *
-     * ATTN: Parameter validation is the responsibility of the caller, or
-     * the restricted method implementation in the case of `params`.
-     *
-     * @see {@link PermissionController.executeRestrictedMethod} and
-     * {@link PermissionController.createPermissionMiddleware} for usage.
-     * @param methodImplementation - The implementation of the method to call.
-     * @param subject - Metadata about the subject that made the request.
-     * @param method - The method name
-     * @param params - Params needed for executing the restricted method
-     * @returns The result of the restricted method implementation
-     */
-    _executeRestrictedMethod(methodImplementation, subject, method, params = []) {
-        const { origin } = subject;
-        const permission = this.getPermission(origin, method);
-        if (!permission) {
-            throw unauthorized({ data: { origin, method } });
-        }
-        return decorateWithCaveats(methodImplementation, permission, this._caveatSpecifications)({ method, params, context: { origin } });
-    }
 }
-_PermissionController_instances = new WeakSet(), _PermissionController_expectGetCaveatMerger = function _PermissionController_expectGetCaveatMerger(caveatType) {
-    const { merger } = this.getCaveatSpecification(caveatType);
+_PermissionController_caveatSpecifications = new WeakMap(), _PermissionController_permissionSpecifications = new WeakMap(), _PermissionController_unrestrictedMethods = new WeakMap(), _PermissionController_instances = new WeakSet(), _PermissionController_getPermissionSpecification = function _PermissionController_getPermissionSpecification(targetName) {
+    return __classPrivateFieldGet(this, _PermissionController_permissionSpecifications, "f")[targetName];
+}, _PermissionController_getCaveatSpecification = function _PermissionController_getCaveatSpecification(caveatType) {
+    return __classPrivateFieldGet(this, _PermissionController_caveatSpecifications, "f")[caveatType];
+}, _PermissionController_expectGetCaveatMerger = function _PermissionController_expectGetCaveatMerger(caveatType) {
+    const { merger } = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getCaveatSpecification).call(this, caveatType);
     if (merger === undefined) {
         throw new CaveatMergerDoesNotExistError(caveatType);
     }
     return merger;
+}, _PermissionController_validatePermissionSpecifications = function _PermissionController_validatePermissionSpecifications(permissionSpecifications, caveatSpecifications) {
+    Object.entries(permissionSpecifications).forEach(([targetName, { permissionType, targetName: innerTargetName, allowedCaveats },]) => {
+        if (!permissionType || !hasProperty(PermissionType, permissionType)) {
+            throw new Error(`Invalid permission type: "${permissionType}"`);
+        }
+        if (!targetName) {
+            throw new Error(`Invalid permission target name: "${targetName}"`);
+        }
+        if (targetName !== innerTargetName) {
+            throw new Error(`Invalid permission specification: target name "${targetName}" must match specification.targetName value "${innerTargetName}".`);
+        }
+        if (allowedCaveats) {
+            allowedCaveats.forEach((caveatType) => {
+                if (!hasProperty(caveatSpecifications, caveatType)) {
+                    throw new UnrecognizedCaveatTypeError(caveatType);
+                }
+                const specification = caveatSpecifications[caveatType];
+                const isRestrictedMethodCaveat = isRestrictedMethodCaveatSpecification(specification);
+                if ((permissionType === PermissionType.RestrictedMethod &&
+                    !isRestrictedMethodCaveat) ||
+                    (permissionType === PermissionType.Endowment &&
+                        isRestrictedMethodCaveat)) {
+                    throw new CaveatSpecificationMismatchError(specification, permissionType);
+                }
+            });
+        }
+    });
+}, _PermissionController_registerMessageHandlers = function _PermissionController_registerMessageHandlers() {
+    this.messenger.registerActionHandler(`${controllerName}:clearPermissions`, () => this.clearState());
+    this.messenger.registerActionHandler(`${controllerName}:getEndowments`, (origin, targetName, requestData) => this.getEndowments(origin, targetName, requestData));
+    this.messenger.registerActionHandler(`${controllerName}:getSubjectNames`, () => this.getSubjectNames());
+    this.messenger.registerActionHandler(`${controllerName}:getPermissions`, (origin) => this.getPermissions(origin));
+    this.messenger.registerActionHandler(`${controllerName}:hasPermission`, (origin, targetName) => this.hasPermission(origin, targetName));
+    this.messenger.registerActionHandler(`${controllerName}:hasPermissions`, (origin) => this.hasPermissions(origin));
+    this.messenger.registerActionHandler(`${controllerName}:grantPermissions`, this.grantPermissions.bind(this));
+    this.messenger.registerActionHandler(`${controllerName}:grantPermissionsIncremental`, this.grantPermissionsIncremental.bind(this));
+    this.messenger.registerActionHandler(`${controllerName}:requestPermissions`, (subject, permissions) => this.requestPermissions(subject, permissions));
+    this.messenger.registerActionHandler(`${controllerName}:requestPermissionsIncremental`, (subject, permissions) => this.requestPermissionsIncremental(subject, permissions));
+    this.messenger.registerActionHandler(`${controllerName}:revokeAllPermissions`, (origin) => this.revokeAllPermissions(origin));
+    this.messenger.registerActionHandler(`${controllerName}:revokePermissionForAllSubjects`, (target) => this.revokePermissionForAllSubjects(target));
+    this.messenger.registerActionHandler(`${controllerName}:revokePermissions`, this.revokePermissions.bind(this));
+    this.messenger.registerActionHandler(`${controllerName}:updateCaveat`, (origin, target, caveatType, caveatValue) => {
+        this.updateCaveat(origin, target, caveatType, caveatValue);
+    });
+    this.messenger.registerActionHandler(`${controllerName}:getCaveat`, (origin, target, caveatType) => this.getCaveat(origin, target, caveatType));
+}, _PermissionController_getTypedPermissionSpecification = function _PermissionController_getTypedPermissionSpecification(permissionType, targetName, requestingOrigin) {
+    const failureError = permissionType === PermissionType.RestrictedMethod
+        ? methodNotFound(targetName, requestingOrigin ? { origin: requestingOrigin } : undefined)
+        : new EndowmentPermissionDoesNotExistError(targetName, requestingOrigin);
+    if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_targetExists).call(this, targetName)) {
+        throw failureError;
+    }
+    const specification = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getPermissionSpecification).call(this, targetName);
+    if (!hasSpecificationType(specification, permissionType)) {
+        throw failureError;
+    }
+    return specification;
+}, _PermissionController_deletePermission = function _PermissionController_deletePermission(subjects, origin, target) {
+    const { permissions } = subjects[origin];
+    if (Object.keys(permissions).length > 1) {
+        delete permissions[target];
+    }
+    else {
+        delete subjects[origin];
+    }
+}, _PermissionController_setCaveat = function _PermissionController_setCaveat(origin, target, caveatType, caveatValue) {
+    this.update((draftState) => {
+        const subject = draftState.subjects[origin];
+        // Unreachable because `hasCaveat` is always called before this, and it
+        // throws if permissions are missing. TypeScript needs this, however.
+        /* istanbul ignore if */
+        if (!subject) {
+            throw new UnrecognizedSubjectError(origin);
+        }
+        const permission = subject.permissions[target];
+        /* istanbul ignore if: practically impossible, but TypeScript wants it */
+        if (!permission) {
+            throw new PermissionDoesNotExistError(origin, target);
+        }
+        const caveat = {
+            type: caveatType,
+            value: caveatValue,
+        };
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateCaveat).call(this, caveat, origin, target);
+        let addedCaveat = false;
+        if (permission.caveats) {
+            const caveatIndex = permission.caveats.findIndex((existingCaveat) => existingCaveat.type === caveat.type);
+            if (caveatIndex === -1) {
+                permission.caveats.push(caveat);
+                addedCaveat = true;
+            }
+            else {
+                permission.caveats.splice(caveatIndex, 1, caveat);
+            }
+        }
+        else {
+            // At this point, we don't know if the specific permission is allowed
+            // to have caveats, but it should be impossible to call this method
+            // for a permission that may not have any caveats. If all else fails,
+            // the permission validator is also called.
+            // @ts-expect-error See above comment
+            permission.caveats = [caveat];
+            addedCaveat = true;
+        }
+        // Mutating a caveat does not warrant permission validation, but mutating
+        // the caveat array does.
+        if (addedCaveat) {
+            __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateModifiedPermission).call(this, permission, origin, {
+                invokePermissionValidator: true,
+                performCaveatValidation: false, // We just validated the caveat
+            });
+        }
+    });
+}, _PermissionController_deleteCaveat = function _PermissionController_deleteCaveat(permission, caveatType, origin) {
+    /* istanbul ignore if: not possible in our usage */
+    if (!permission.caveats) {
+        throw new CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
+    }
+    const caveatIndex = permission.caveats.findIndex((existingCaveat) => existingCaveat.type === caveatType);
+    if (caveatIndex === -1) {
+        throw new CaveatDoesNotExistError(origin, permission.parentCapability, caveatType);
+    }
+    if (permission.caveats.length === 1) {
+        permission.caveats = null;
+    }
+    else {
+        permission.caveats.splice(caveatIndex, 1);
+    }
+    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateModifiedPermission).call(this, permission, origin, {
+        invokePermissionValidator: true,
+        performCaveatValidation: false, // No caveat object was mutated
+    });
+}, _PermissionController_validateModifiedPermission = function _PermissionController_validateModifiedPermission(permission, origin, validationFlags) {
+    /* istanbul ignore if: this should be impossible */
+    if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_targetExists).call(this, permission.parentCapability)) {
+        throw new Error(`Fatal: Existing permission target "${permission.parentCapability}" has no specification.`);
+    }
+    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validatePermission).call(this, __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getPermissionSpecification).call(this, permission.parentCapability), permission, origin, validationFlags);
+}, _PermissionController_targetExists = function _PermissionController_targetExists(target) {
+    return hasProperty(__classPrivateFieldGet(this, _PermissionController_permissionSpecifications, "f"), target);
 }, _PermissionController_applyGrantedPermissions = function _PermissionController_applyGrantedPermissions({ approvedPermissions, subject, mergePermissions, preserveExistingPermissions, requestData, }) {
     const { origin } = subject;
     if (!origin || typeof origin !== 'string') {
@@ -1344,7 +894,7 @@ _PermissionController_instances = new WeakSet(), _PermissionController_expectGet
         }
         : {});
     for (const [requestedTarget, approvedPermission] of Object.entries(approvedPermissions)) {
-        if (!this.targetExists(requestedTarget)) {
+        if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_targetExists).call(this, requestedTarget)) {
             throw methodNotFound(requestedTarget);
         }
         if (approvedPermission.parentCapability !== undefined &&
@@ -1354,9 +904,9 @@ _PermissionController_instances = new WeakSet(), _PermissionController_expectGet
         // We have verified that the target exists, and reassign it to change its
         // type.
         const targetName = requestedTarget;
-        const specification = this.getPermissionSpecification(targetName);
+        const specification = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getPermissionSpecification).call(this, targetName);
         // The requested caveats are validated here.
-        const caveats = this.constructCaveats(origin, targetName, approvedPermission.caveats);
+        const caveats = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_constructCaveats).call(this, origin, targetName, approvedPermission.caveats);
         const permissionOptions = {
             caveats,
             invoker: origin,
@@ -1372,14 +922,120 @@ _PermissionController_instances = new WeakSet(), _PermissionController_expectGet
         if (mergePermissions) {
             permission = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_mergePermission).call(this, permissions[targetName], permission)[0];
         }
-        this.validatePermission(specification, permission, origin, {
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validatePermission).call(this, specification, permission, origin, {
             invokePermissionValidator: true,
             performCaveatValidation: true,
         });
         permissions[targetName] = permission;
     }
-    this.setValidatedPermissions(origin, permissions);
+    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_setValidatedPermissions).call(this, origin, permissions);
     return permissions;
+}, _PermissionController_validatePermission = function _PermissionController_validatePermission(specification, permission, origin, { invokePermissionValidator, performCaveatValidation, }) {
+    const { allowedCaveats, validator, targetName } = specification;
+    if (specification.subjectTypes?.length &&
+        specification.subjectTypes.length > 0) {
+        const metadata = this.messenger.call('SubjectMetadataController:getSubjectMetadata', origin);
+        if (!metadata ||
+            metadata.subjectType === null ||
+            !specification.subjectTypes.includes(metadata.subjectType)) {
+            throw specification.permissionType === PermissionType.RestrictedMethod
+                ? methodNotFound(targetName, { origin })
+                : new EndowmentPermissionDoesNotExistError(targetName, origin);
+        }
+    }
+    if (hasProperty(permission, 'caveats')) {
+        const { caveats } = permission;
+        if (caveats !== null && !(Array.isArray(caveats) && caveats.length > 0)) {
+            throw new InvalidCaveatsPropertyError(origin, targetName, caveats);
+        }
+        const seenCaveatTypes = new Set();
+        caveats?.forEach((caveat) => {
+            if (performCaveatValidation) {
+                __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateCaveat).call(this, caveat, origin, targetName);
+            }
+            if (!allowedCaveats?.includes(caveat.type)) {
+                throw new ForbiddenCaveatError(caveat.type, origin, targetName);
+            }
+            if (seenCaveatTypes.has(caveat.type)) {
+                throw new DuplicateCaveatError(caveat.type, origin, targetName);
+            }
+            seenCaveatTypes.add(caveat.type);
+        });
+    }
+    if (invokePermissionValidator && validator) {
+        validator(permission, origin, targetName);
+    }
+}, _PermissionController_setValidatedPermissions = function _PermissionController_setValidatedPermissions(origin, permissions) {
+    this.update((draftState) => {
+        if (!draftState.subjects[origin]) {
+            draftState.subjects[origin] = { origin, permissions: {} };
+        }
+        draftState.subjects[origin].permissions = castDraft(permissions);
+    });
+}, _PermissionController_constructCaveats = function _PermissionController_constructCaveats(origin, target, requestedCaveats) {
+    const caveatArray = requestedCaveats?.map((requestedCaveat) => {
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateCaveat).call(this, requestedCaveat, origin, target);
+        // Reassign so that we have a fresh object.
+        const { type, value } = requestedCaveat;
+        return { type, value };
+    });
+    return caveatArray && isNonEmptyArray(caveatArray)
+        ? caveatArray
+        : undefined;
+}, _PermissionController_validateCaveat = function _PermissionController_validateCaveat(caveat, origin, target) {
+    if (!isPlainObject(caveat)) {
+        throw new InvalidCaveatError(caveat, origin, target);
+    }
+    if (Object.keys(caveat).length !== 2) {
+        throw new InvalidCaveatFieldsError(caveat, origin, target);
+    }
+    if (typeof caveat.type !== 'string') {
+        throw new InvalidCaveatTypeError(caveat, origin, target);
+    }
+    const specification = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getCaveatSpecification).call(this, caveat.type);
+    if (!specification) {
+        throw new UnrecognizedCaveatTypeError(caveat.type, origin, target);
+    }
+    if (!hasProperty(caveat, 'value') || caveat.value === undefined) {
+        throw new CaveatMissingValueError(caveat, origin, target);
+    }
+    if (!isValidJson(caveat.value)) {
+        throw new CaveatInvalidJsonError(caveat, origin, target);
+    }
+    // Typecast: TypeScript still believes that the caveat is a PlainObject.
+    specification.validator?.(caveat, origin, target);
+}, _PermissionController_validateRequestedPermissions = function _PermissionController_validateRequestedPermissions(origin, requestedPermissions) {
+    if (!isPlainObject(requestedPermissions)) {
+        throw invalidParams({
+            message: `Requested permissions for origin "${origin}" is not a plain object.`,
+            data: { origin, requestedPermissions },
+        });
+    }
+    if (Object.keys(requestedPermissions).length === 0) {
+        throw invalidParams({
+            message: `Permissions request for origin "${origin}" contains no permissions.`,
+            data: { requestedPermissions },
+        });
+    }
+    for (const targetName of Object.keys(requestedPermissions)) {
+        const permission = requestedPermissions[targetName];
+        if (!__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_targetExists).call(this, targetName)) {
+            throw methodNotFound(targetName, { origin, requestedPermissions });
+        }
+        if (!isPlainObject(permission) ||
+            (permission.parentCapability !== undefined &&
+                targetName !== permission.parentCapability)) {
+            throw invalidParams({
+                message: `Permissions request for origin "${origin}" contains invalid requested permission(s).`,
+                data: { origin, requestedPermissions },
+            });
+        }
+        // Here we validate the permission without invoking its validator, if any.
+        // The validator will be invoked after the permission has been approved.
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validatePermission).call(this, __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getPermissionSpecification).call(this, targetName), 
+        // Typecast: The permission is still a "PlainObject" here.
+        permission, origin, { invokePermissionValidator: false, performCaveatValidation: true });
+    }
 }, _PermissionController_mergeIncrementalPermissions = function _PermissionController_mergeIncrementalPermissions(existingPermissions, incrementalRequestedPermissions) {
     const permissionDiffMap = {};
     // Use immer's produce as a convenience for calculating the new permissions
@@ -1457,6 +1113,25 @@ _PermissionController_instances = new WeakSet(), _PermissionController_expectGet
             diff,
         ]
         : [];
+}, _PermissionController_requestUserApproval = 
+/**
+ * Adds a request to the {@link ApprovalController} using the
+ * {@link ApprovalControllerAddRequestAction} action. Also validates the resulting approved
+ * permissions request, and throws an error if validation fails.
+ *
+ * @param permissionsRequest - The permissions request object.
+ * @returns The approved permissions request object.
+ */
+async function _PermissionController_requestUserApproval(permissionsRequest) {
+    const { origin, id } = permissionsRequest.metadata;
+    const approvedRequest = await this.messenger.call('ApprovalController:addRequest', {
+        id,
+        origin,
+        requestData: permissionsRequest,
+        type: MethodNames.RequestPermissions,
+    }, true);
+    __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateApprovedPermissions).call(this, approvedRequest, { id, origin });
+    return approvedRequest;
 }, _PermissionController_handleApprovedPermissions = 
 /**
  * Accepts a permissions request that has been approved by the user. This
@@ -1474,9 +1149,9 @@ _PermissionController_instances = new WeakSet(), _PermissionController_expectGet
 async function _PermissionController_handleApprovedPermissions({ subject, metadata, preserveExistingPermissions, approvedRequest, }) {
     const { permissions: approvedPermissions, ...requestData } = approvedRequest;
     const approvedMetadata = { ...metadata };
-    const sideEffects = this.getSideEffects(approvedPermissions);
+    const sideEffects = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getSideEffects).call(this, approvedPermissions);
     if (Object.values(sideEffects.permittedHandlers).length > 0) {
-        const sideEffectsData = await this.executeSideEffects(sideEffects, approvedRequest);
+        const sideEffectsData = await __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_executeSideEffects).call(this, sideEffects, approvedRequest);
         approvedMetadata.data = Object.keys(sideEffects.permittedHandlers).reduce((acc, permission, i) => ({ [permission]: sideEffectsData[i], ...acc }), {});
     }
     return [
@@ -1488,5 +1163,94 @@ async function _PermissionController_handleApprovedPermissions({ subject, metada
         }),
         approvedMetadata,
     ];
+}, _PermissionController_getSideEffects = function _PermissionController_getSideEffects(permissions) {
+    return Object.keys(permissions).reduce((sideEffectList, targetName) => {
+        if (__classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_targetExists).call(this, targetName)) {
+            const specification = __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_getPermissionSpecification).call(this, targetName);
+            if (specification.sideEffect) {
+                sideEffectList.permittedHandlers[targetName] =
+                    specification.sideEffect.onPermitted;
+                if (specification.sideEffect.onFailure) {
+                    sideEffectList.failureHandlers[targetName] =
+                        specification.sideEffect.onFailure;
+                }
+            }
+        }
+        return sideEffectList;
+    }, { permittedHandlers: {}, failureHandlers: {} });
+}, _PermissionController_executeSideEffects = 
+/**
+ * Executes the side-effects of the approved permissions while handling the errors if any.
+ * It will pass an instance of the {@link messenger} and the request data associated with the permission request to the handlers through its params.
+ *
+ * @param sideEffects - the side-effect record created by {@link #getSideEffects}
+ * @param requestData - the permissions requestData.
+ * @returns the value returned by all the `onPermitted` handlers in an array.
+ */
+async function _PermissionController_executeSideEffects(sideEffects, requestData) {
+    const { permittedHandlers, failureHandlers } = sideEffects;
+    const params = {
+        requestData,
+        messenger: this.messenger,
+    };
+    const promiseResults = await Promise.allSettled(Object.values(permittedHandlers).map((permittedHandler) => permittedHandler(params)));
+    // lib.es2020.promise.d.ts does not export its types so we're using a simple type.
+    const rejectedHandlers = promiseResults.filter((promise) => promise.status === 'rejected');
+    if (rejectedHandlers.length > 0) {
+        const failureHandlersList = Object.values(failureHandlers);
+        if (failureHandlersList.length > 0) {
+            try {
+                await Promise.all(failureHandlersList.map((failureHandler) => failureHandler(params)));
+            }
+            catch (error) {
+                throw internalError('Unexpected error in side-effects', { error });
+            }
+        }
+        const reasons = rejectedHandlers.map((handler) => handler.reason);
+        reasons.forEach((reason) => {
+            console.error(reason);
+        });
+        throw reasons.length > 1
+            ? internalError('Multiple errors occurred during side-effects execution', { errors: reasons })
+            : reasons[0];
+    }
+    // lib.es2020.promise.d.ts does not export its types so we're using a simple type.
+    return promiseResults.map(({ value }) => value);
+}, _PermissionController_validateApprovedPermissions = function _PermissionController_validateApprovedPermissions(approvedRequest, originalMetadata) {
+    const { id, origin } = originalMetadata;
+    if (!isPlainObject(approvedRequest) ||
+        !isPlainObject(approvedRequest.metadata)) {
+        throw internalError(`Approved permissions request for subject "${origin}" is invalid.`, { data: { approvedRequest } });
+    }
+    const { metadata: { id: newId, origin: newOrigin }, permissions, } = approvedRequest;
+    if (newId !== id) {
+        throw internalError(`Approved permissions request for subject "${origin}" mutated its id.`, { originalId: id, mutatedId: newId });
+    }
+    if (newOrigin !== origin) {
+        throw internalError(`Approved permissions request for subject "${origin}" mutated its origin.`, { originalOrigin: origin, mutatedOrigin: newOrigin });
+    }
+    try {
+        __classPrivateFieldGet(this, _PermissionController_instances, "m", _PermissionController_validateRequestedPermissions).call(this, origin, permissions);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            // Re-throw as an internal error; we should never receive invalid approved
+            // permissions.
+            throw internalError(`Invalid approved permissions request: ${error.message}`, error instanceof JsonRpcError ? error.data : undefined);
+        }
+        /* istanbul ignore next: This should be impossible */
+        throw internalError('Unrecognized error type', { error });
+    }
+}, _PermissionController_hasApprovalRequest = function _PermissionController_hasApprovalRequest(options) {
+    return this.messenger.call('ApprovalController:hasRequest', options);
+}, _PermissionController_rejectPermissionsRequest = function _PermissionController_rejectPermissionsRequest(id, error) {
+    return this.messenger.call('ApprovalController:rejectRequest', id, error);
+}, _PermissionController_executeRestrictedMethod = function _PermissionController_executeRestrictedMethod(methodImplementation, subject, method, params = []) {
+    const { origin } = subject;
+    const permission = this.getPermission(origin, method);
+    if (!permission) {
+        throw unauthorized({ data: { origin, method } });
+    }
+    return decorateWithCaveats(methodImplementation, permission, __classPrivateFieldGet(this, _PermissionController_caveatSpecifications, "f"))({ method, params, context: { origin } });
 };
 //# sourceMappingURL=PermissionController.mjs.map