@metamask/permission-controller 11.0.1 → 11.0.2

package/dist/permission-middleware.mjs

@@ -1,9 +1,51 @@
-import {
-  getPermissionMiddlewareFactory
-} from "./chunk-I62TTXZ6.mjs";
-import "./chunk-G4BWJ7EA.mjs";
-import "./chunk-2L4QPE5A.mjs";
-export {
-  getPermissionMiddlewareFactory
-};
+import { createAsyncMiddleware } from "@metamask/json-rpc-engine";
+import { internalError } from "./errors.mjs";
+/**
+ * Creates a permission middleware function factory. Intended for internal use
+ * in the {@link PermissionController}. Like any {@link JsonRpcEngine}
+ * middleware, each middleware will only receive requests from a particular
+ * subject / origin. However, each middleware also requires access to some
+ * `PermissionController` internals, which is why this "factory factory" exists.
+ *
+ * The middlewares returned by the factory will pass through requests for
+ * unrestricted methods, and attempt to execute restricted methods. If a method
+ * is neither restricted nor unrestricted, a "method not found" error will be
+ * returned.
+ * If a method is restricted, the middleware will first attempt to retrieve the
+ * subject's permission for that method. If the permission is found, the method
+ * will be executed. Otherwise, an "unauthorized" error will be returned.
+ *
+ * @param options - Options bag.
+ * @param options.executeRestrictedMethod - {@link PermissionController._executeRestrictedMethod}.
+ * @param options.getRestrictedMethod - {@link PermissionController.getRestrictedMethod}.
+ * @param options.isUnrestrictedMethod - A function that checks whether a
+ * particular method is unrestricted.
+ * @returns A permission middleware factory function.
+ */
+export function getPermissionMiddlewareFactory({ executeRestrictedMethod, getRestrictedMethod, isUnrestrictedMethod, }) {
+    return function createPermissionMiddleware(subject) {
+        const { origin } = subject;
+        if (typeof origin !== 'string' || !origin) {
+            throw new Error('The subject "origin" must be a non-empty string.');
+        }
+        const permissionsMiddleware = async (req, res, next) => {
+            const { method, params } = req;
+            // Skip registered unrestricted methods.
+            if (isUnrestrictedMethod(method)) {
+                return next();
+            }
+            // This will throw if no restricted method implementation is found.
+            const methodImplementation = getRestrictedMethod(method, origin);
+            // This will throw if the permission does not exist.
+            const result = await executeRestrictedMethod(methodImplementation, subject, method, params);
+            if (result === undefined) {
+                res.error = internalError(`Request for method "${req.method}" returned undefined result.`, { request: req });
+                return undefined;
+            }
+            res.result = result;
+            return undefined;
+        };
+        return createAsyncMiddleware(permissionsMiddleware);
+    };
+}
 //# sourceMappingURL=permission-middleware.mjs.map

package/dist/permission-middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"permission-middleware.mjs","sourceRoot":"","sources":["../src/permission-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,kCAAkC;AAkBlE,OAAO,EAAE,aAAa,EAAE,qBAAiB;AAUzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,8BAA8B,CAAC,EAC7C,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,GACe;IACnC,OAAO,SAAS,0BAA0B,CACxC,OAAkC;QAElC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAC3B,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,MAAM,EAAE;YACzC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACrE;QAED,MAAM,qBAAqB,GAAG,KAAK,EACjC,GAA+C,EAC/C,GAAiC,EACjC,IAAoC,EACrB,EAAE;YACjB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;YAE/B,wCAAwC;YACxC,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE;gBAChC,OAAO,IAAI,EAAE,CAAC;aACf;YAED,mEAAmE;YACnE,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAEjE,oDAAoD;YACpD,MAAM,MAAM,GAAG,MAAM,uBAAuB,CAC1C,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,MAAM,CACP,CAAC;YAEF,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,GAAG,CAAC,KAAK,GAAG,aAAa,CACvB,uBAAuB,GAAG,CAAC,MAAM,8BAA8B,EAC/D,EAAE,OAAO,EAAE,GAAG,EAAE,CACjB,CAAC;gBACF,OAAO,SAAS,CAAC;aAClB;YAED,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;YACpB,OAAO,SAAS,CAAC;QACnB,CAAC,CAAC;QAEF,OAAO,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;IACtD,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { createAsyncMiddleware } from '@metamask/json-rpc-engine';\nimport type {\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  JsonRpcEngine,\n  JsonRpcMiddleware,\n  AsyncJsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type {\n  Json,\n  PendingJsonRpcResponse,\n  JsonRpcRequest,\n} from '@metamask/utils';\n\nimport type {\n  GenericPermissionController,\n  PermissionSubjectMetadata,\n  RestrictedMethodParameters,\n} from '.';\nimport { internalError } from './errors';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { PermissionController } from './PermissionController';\n\ntype PermissionMiddlewareFactoryOptions = {\n  executeRestrictedMethod: GenericPermissionController['_executeRestrictedMethod'];\n  getRestrictedMethod: GenericPermissionController['getRestrictedMethod'];\n  isUnrestrictedMethod: (method: string) => boolean;\n};\n\n/**\n * Creates a permission middleware function factory. Intended for internal use\n * in the {@link PermissionController}. Like any {@link JsonRpcEngine}\n * middleware, each middleware will only receive requests from a particular\n * subject / origin. However, each middleware also requires access to some\n * `PermissionController` internals, which is why this \"factory factory\" exists.\n *\n * The middlewares returned by the factory will pass through requests for\n * unrestricted methods, and attempt to execute restricted methods. If a method\n * is neither restricted nor unrestricted, a \"method not found\" error will be\n * returned.\n * If a method is restricted, the middleware will first attempt to retrieve the\n * subject's permission for that method. If the permission is found, the method\n * will be executed. Otherwise, an \"unauthorized\" error will be returned.\n *\n * @param options - Options bag.\n * @param options.executeRestrictedMethod - {@link PermissionController._executeRestrictedMethod}.\n * @param options.getRestrictedMethod - {@link PermissionController.getRestrictedMethod}.\n * @param options.isUnrestrictedMethod - A function that checks whether a\n * particular method is unrestricted.\n * @returns A permission middleware factory function.\n */\nexport function getPermissionMiddlewareFactory({\n  executeRestrictedMethod,\n  getRestrictedMethod,\n  isUnrestrictedMethod,\n}: PermissionMiddlewareFactoryOptions) {\n  return function createPermissionMiddleware(\n    subject: PermissionSubjectMetadata,\n  ): JsonRpcMiddleware<RestrictedMethodParameters, Json> {\n    const { origin } = subject;\n    if (typeof origin !== 'string' || !origin) {\n      throw new Error('The subject \"origin\" must be a non-empty string.');\n    }\n\n    const permissionsMiddleware = async (\n      req: JsonRpcRequest<RestrictedMethodParameters>,\n      res: PendingJsonRpcResponse<Json>,\n      next: AsyncJsonRpcEngineNextCallback,\n    ): Promise<void> => {\n      const { method, params } = req;\n\n      // Skip registered unrestricted methods.\n      if (isUnrestrictedMethod(method)) {\n        return next();\n      }\n\n      // This will throw if no restricted method implementation is found.\n      const methodImplementation = getRestrictedMethod(method, origin);\n\n      // This will throw if the permission does not exist.\n      const result = await executeRestrictedMethod(\n        methodImplementation,\n        subject,\n        method,\n        params,\n      );\n\n      if (result === undefined) {\n        res.error = internalError(\n          `Request for method \"${req.method}\" returned undefined result.`,\n          { request: req },\n        );\n        return undefined;\n      }\n\n      res.result = result;\n      return undefined;\n    };\n\n    return createAsyncMiddleware(permissionsMiddleware);\n  };\n}\n"]}

package/dist/rpc-methods/getPermissions.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermissionsHandler = void 0;
+const utils_1 = require("../utils.cjs");
+exports.getPermissionsHandler = {
+    methodNames: [utils_1.MethodNames.GetPermissions],
+    implementation: getPermissionsImplementation,
+    hookNames: {
+        getPermissionsForOrigin: true,
+    },
+};
+/**
+ * Get Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param _req - The JsonRpcEngine request - unused
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.getPermissionsForOrigin - The specific method hook needed for this method implementation
+ * @returns A promise that resolves to nothing
+ */
+async function getPermissionsImplementation(_req, res, _next, end, { getPermissionsForOrigin }) {
+    res.result = Object.values(getPermissionsForOrigin() || {});
+    return end();
+}
+//# sourceMappingURL=getPermissions.cjs.map

package/dist/rpc-methods/getPermissions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPermissions.cjs","sourceRoot":"","sources":["../../src/rpc-methods/getPermissions.ts"],"names":[],"mappings":";;;AAMA,wCAAuC;AAE1B,QAAA,qBAAqB,GAI9B;IACF,WAAW,EAAE,CAAC,mBAAW,CAAC,cAAc,CAAC;IACzC,cAAc,EAAE,4BAA4B;IAC5C,SAAS,EAAE;QACT,uBAAuB,EAAE,IAAI;KAC9B;CACF,CAAC;AAOF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,4BAA4B,CACzC,IAAa,EACb,GAAmD,EACnD,KAAc,EACd,GAA6B,EAC7B,EAAE,uBAAuB,EAAuB;IAEhD,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { PermissionConstraint } from '../Permission';\nimport type { SubjectPermissions } from '../PermissionController';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const getPermissionsHandler: PermittedHandlerExport<\n  GetPermissionsHooks,\n  [],\n  PermissionConstraint[]\n> = {\n  methodNames: [MethodNames.GetPermissions],\n  implementation: getPermissionsImplementation,\n  hookNames: {\n    getPermissionsForOrigin: true,\n  },\n};\n\nexport type GetPermissionsHooks = {\n  // This must be bound to the requesting origin.\n  getPermissionsForOrigin: () => SubjectPermissions<PermissionConstraint>;\n};\n\n/**\n * Get Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param _req - The JsonRpcEngine request - unused\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.getPermissionsForOrigin - The specific method hook needed for this method implementation\n * @returns A promise that resolves to nothing\n */\nasync function getPermissionsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<PermissionConstraint[]>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getPermissionsForOrigin }: GetPermissionsHooks,\n): Promise<void> {\n  res.result = Object.values(getPermissionsForOrigin() || {});\n  return end();\n}\n"]}

package/dist/rpc-methods/getPermissions.d.cts

@@ -0,0 +1,9 @@
+import type { PermissionConstraint } from "../Permission.cjs";
+import type { SubjectPermissions } from "../PermissionController.cjs";
+import type { PermittedHandlerExport } from "../utils.cjs";
+export declare const getPermissionsHandler: PermittedHandlerExport<GetPermissionsHooks, [
+], PermissionConstraint[]>;
+export type GetPermissionsHooks = {
+    getPermissionsForOrigin: () => SubjectPermissions<PermissionConstraint>;
+};
+//# sourceMappingURL=getPermissions.d.cts.map

package/dist/rpc-methods/getPermissions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPermissions.d.cts","sourceRoot":"","sources":["../../src/rpc-methods/getPermissions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAAsB;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,oCAAgC;AAClE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,qBAAqB,EAAE,sBAAsB,CACxD,mBAAmB,EACnB;CAAE,EACF,oBAAoB,EAAE,CAOvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,uBAAuB,EAAE,MAAM,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;CACzE,CAAC"}

package/dist/rpc-methods/getPermissions.d.mts

@@ -0,0 +1,9 @@
+import type { PermissionConstraint } from "../Permission.mjs";
+import type { SubjectPermissions } from "../PermissionController.mjs";
+import type { PermittedHandlerExport } from "../utils.mjs";
+export declare const getPermissionsHandler: PermittedHandlerExport<GetPermissionsHooks, [
+], PermissionConstraint[]>;
+export type GetPermissionsHooks = {
+    getPermissionsForOrigin: () => SubjectPermissions<PermissionConstraint>;
+};
+//# sourceMappingURL=getPermissions.d.mts.map

package/dist/rpc-methods/getPermissions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPermissions.d.mts","sourceRoot":"","sources":["../../src/rpc-methods/getPermissions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAAsB;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,oCAAgC;AAClE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,qBAAqB,EAAE,sBAAsB,CACxD,mBAAmB,EACnB;CAAE,EACF,oBAAoB,EAAE,CAOvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,uBAAuB,EAAE,MAAM,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;CACzE,CAAC"}

package/dist/rpc-methods/getPermissions.mjs

@@ -1,9 +1,24 @@
-import {
-  getPermissionsHandler
-} from "../chunk-5RFW5THA.mjs";
-import "../chunk-4NAVRO44.mjs";
-import "../chunk-2L4QPE5A.mjs";
-export {
-  getPermissionsHandler
+import { MethodNames } from "../utils.mjs";
+export const getPermissionsHandler = {
+    methodNames: [MethodNames.GetPermissions],
+    implementation: getPermissionsImplementation,
+    hookNames: {
+        getPermissionsForOrigin: true,
+    },
 };
+/**
+ * Get Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param _req - The JsonRpcEngine request - unused
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.getPermissionsForOrigin - The specific method hook needed for this method implementation
+ * @returns A promise that resolves to nothing
+ */
+async function getPermissionsImplementation(_req, res, _next, end, { getPermissionsForOrigin }) {
+    res.result = Object.values(getPermissionsForOrigin() || {});
+    return end();
+}
 //# sourceMappingURL=getPermissions.mjs.map

package/dist/rpc-methods/getPermissions.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"getPermissions.mjs","sourceRoot":"","sources":["../../src/rpc-methods/getPermissions.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,qBAAiB;AAEvC,MAAM,CAAC,MAAM,qBAAqB,GAI9B;IACF,WAAW,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC;IACzC,cAAc,EAAE,4BAA4B;IAC5C,SAAS,EAAE;QACT,uBAAuB,EAAE,IAAI;KAC9B;CACF,CAAC;AAOF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,4BAA4B,CACzC,IAAa,EACb,GAAmD,EACnD,KAAc,EACd,GAA6B,EAC7B,EAAE,uBAAuB,EAAuB;IAEhD,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { PendingJsonRpcResponse } from '@metamask/utils';\n\nimport type { PermissionConstraint } from '../Permission';\nimport type { SubjectPermissions } from '../PermissionController';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const getPermissionsHandler: PermittedHandlerExport<\n  GetPermissionsHooks,\n  [],\n  PermissionConstraint[]\n> = {\n  methodNames: [MethodNames.GetPermissions],\n  implementation: getPermissionsImplementation,\n  hookNames: {\n    getPermissionsForOrigin: true,\n  },\n};\n\nexport type GetPermissionsHooks = {\n  // This must be bound to the requesting origin.\n  getPermissionsForOrigin: () => SubjectPermissions<PermissionConstraint>;\n};\n\n/**\n * Get Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param _req - The JsonRpcEngine request - unused\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.getPermissionsForOrigin - The specific method hook needed for this method implementation\n * @returns A promise that resolves to nothing\n */\nasync function getPermissionsImplementation(\n  _req: unknown,\n  res: PendingJsonRpcResponse<PermissionConstraint[]>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { getPermissionsForOrigin }: GetPermissionsHooks,\n): Promise<void> {\n  res.result = Object.values(getPermissionsForOrigin() || {});\n  return end();\n}\n"]}

package/dist/rpc-methods/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlers = void 0;
+const getPermissions_1 = require("./getPermissions.cjs");
+const requestPermissions_1 = require("./requestPermissions.cjs");
+const revokePermissions_1 = require("./revokePermissions.cjs");
+exports.handlers = [
+    requestPermissions_1.requestPermissionsHandler,
+    getPermissions_1.getPermissionsHandler,
+    revokePermissions_1.revokePermissionsHandler,
+];
+//# sourceMappingURL=index.cjs.map

package/dist/rpc-methods/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../src/rpc-methods/index.ts"],"names":[],"mappings":";;;AACA,yDAAyD;AAEzD,iEAAiE;AAEjE,+DAA+D;AAMlD,QAAA,QAAQ,GAAG;IACtB,8CAAyB;IACzB,sCAAqB;IACrB,4CAAwB;CAChB,CAAC","sourcesContent":["import type { GetPermissionsHooks } from './getPermissions';\nimport { getPermissionsHandler } from './getPermissions';\nimport type { RequestPermissionsHooks } from './requestPermissions';\nimport { requestPermissionsHandler } from './requestPermissions';\nimport type { RevokePermissionsHooks } from './revokePermissions';\nimport { revokePermissionsHandler } from './revokePermissions';\n\nexport type PermittedRpcMethodHooks = RequestPermissionsHooks &\n  GetPermissionsHooks &\n  RevokePermissionsHooks;\n\nexport const handlers = [\n  requestPermissionsHandler,\n  getPermissionsHandler,\n  revokePermissionsHandler,\n] as const;\n"]}

package/dist/rpc-methods/index.d.cts

@@ -0,0 +1,6 @@
+import type { GetPermissionsHooks } from "./getPermissions.cjs";
+import type { RequestPermissionsHooks } from "./requestPermissions.cjs";
+import type { RevokePermissionsHooks } from "./revokePermissions.cjs";
+export type PermittedRpcMethodHooks = RequestPermissionsHooks & GetPermissionsHooks & RevokePermissionsHooks;
+export declare const handlers: readonly [import("../index.cjs").PermittedHandlerExport<RequestPermissionsHooks, [import("../index.cjs").RequestedPermissions], import("../index.cjs").PermissionConstraint[]>, import("../index.cjs").PermittedHandlerExport<GetPermissionsHooks, [], import("../index.cjs").PermissionConstraint[]>, import("../index.cjs").PermittedHandlerExport<RevokePermissionsHooks, import("./revokePermissions.cjs").RevokePermissionArgs, null>];
+//# sourceMappingURL=index.d.cts.map

package/dist/rpc-methods/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/rpc-methods/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,6BAAyB;AAE5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,iCAA6B;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAA4B;AAGlE,MAAM,MAAM,uBAAuB,GAAG,uBAAuB,GAC3D,mBAAmB,GACnB,sBAAsB,CAAC;AAEzB,eAAO,MAAM,QAAQ,6WAIX,CAAC"}

package/dist/rpc-methods/index.d.mts

@@ -0,0 +1,6 @@
+import type { GetPermissionsHooks } from "./getPermissions.mjs";
+import type { RequestPermissionsHooks } from "./requestPermissions.mjs";
+import type { RevokePermissionsHooks } from "./revokePermissions.mjs";
+export type PermittedRpcMethodHooks = RequestPermissionsHooks & GetPermissionsHooks & RevokePermissionsHooks;
+export declare const handlers: readonly [import("../index.mjs").PermittedHandlerExport<RequestPermissionsHooks, [import("../index.mjs").RequestedPermissions], import("../index.mjs").PermissionConstraint[]>, import("../index.mjs").PermittedHandlerExport<GetPermissionsHooks, [], import("../index.mjs").PermissionConstraint[]>, import("../index.mjs").PermittedHandlerExport<RevokePermissionsHooks, import("./revokePermissions.mjs").RevokePermissionArgs, null>];
+//# sourceMappingURL=index.d.mts.map

package/dist/rpc-methods/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/rpc-methods/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,6BAAyB;AAE5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,iCAA6B;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAA4B;AAGlE,MAAM,MAAM,uBAAuB,GAAG,uBAAuB,GAC3D,mBAAmB,GACnB,sBAAsB,CAAC;AAEzB,eAAO,MAAM,QAAQ,6WAIX,CAAC"}

package/dist/rpc-methods/index.mjs

@@ -1,13 +1,9 @@
-import {
-  handlers
-} from "../chunk-4FMYQC3Y.mjs";
-import "../chunk-5RFW5THA.mjs";
-import "../chunk-OCLNDUYO.mjs";
-import "../chunk-74H4CVH7.mjs";
-import "../chunk-G4BWJ7EA.mjs";
-import "../chunk-4NAVRO44.mjs";
-import "../chunk-2L4QPE5A.mjs";
-export {
-  handlers
-};
+import { getPermissionsHandler } from "./getPermissions.mjs";
+import { requestPermissionsHandler } from "./requestPermissions.mjs";
+import { revokePermissionsHandler } from "./revokePermissions.mjs";
+export const handlers = [
+    requestPermissionsHandler,
+    getPermissionsHandler,
+    revokePermissionsHandler,
+];
 //# sourceMappingURL=index.mjs.map

package/dist/rpc-methods/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/rpc-methods/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,6BAAyB;AAEzD,OAAO,EAAE,yBAAyB,EAAE,iCAA6B;AAEjE,OAAO,EAAE,wBAAwB,EAAE,gCAA4B;AAM/D,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,yBAAyB;IACzB,qBAAqB;IACrB,wBAAwB;CAChB,CAAC","sourcesContent":["import type { GetPermissionsHooks } from './getPermissions';\nimport { getPermissionsHandler } from './getPermissions';\nimport type { RequestPermissionsHooks } from './requestPermissions';\nimport { requestPermissionsHandler } from './requestPermissions';\nimport type { RevokePermissionsHooks } from './revokePermissions';\nimport { revokePermissionsHandler } from './revokePermissions';\n\nexport type PermittedRpcMethodHooks = RequestPermissionsHooks &\n  GetPermissionsHooks &\n  RevokePermissionsHooks;\n\nexport const handlers = [\n  requestPermissionsHandler,\n  getPermissionsHandler,\n  revokePermissionsHandler,\n] as const;\n"]}

package/dist/rpc-methods/requestPermissions.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestPermissionsHandler = void 0;
+const controller_utils_1 = require("@metamask/controller-utils");
+const errors_1 = require("../errors.cjs");
+const utils_1 = require("../utils.cjs");
+exports.requestPermissionsHandler = {
+    methodNames: [utils_1.MethodNames.RequestPermissions],
+    implementation: requestPermissionsImplementation,
+    hookNames: {
+        requestPermissionsForOrigin: true,
+    },
+};
+/**
+ * Request Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param req - The JsonRpcEngine request
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.requestPermissionsForOrigin - The specific method hook needed for this method implementation
+ * @returns A promise that resolves to nothing
+ */
+async function requestPermissionsImplementation(req, res, _next, end, { requestPermissionsForOrigin }) {
+    const { params } = req;
+    if (!Array.isArray(params) || !(0, controller_utils_1.isPlainObject)(params[0])) {
+        return end((0, errors_1.invalidParams)({ data: { request: req } }));
+    }
+    const [requestedPermissions] = params;
+    const [grantedPermissions] = await requestPermissionsForOrigin(requestedPermissions);
+    // `wallet_requestPermission` is specified to return an array.
+    res.result = Object.values(grantedPermissions);
+    return end();
+}
+//# sourceMappingURL=requestPermissions.cjs.map

package/dist/rpc-methods/requestPermissions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestPermissions.cjs","sourceRoot":"","sources":["../../src/rpc-methods/requestPermissions.ts"],"names":[],"mappings":";;;AAAA,iEAA2D;AAI3D,0CAA0C;AAG1C,wCAAuC;AAE1B,QAAA,yBAAyB,GAIlC;IACF,WAAW,EAAE,CAAC,mBAAW,CAAC,kBAAkB,CAAC;IAC7C,cAAc,EAAE,gCAAgC;IAChD,SAAS,EAAE;QACT,2BAA2B,EAAE,IAAI;KAClC;CACF,CAAC;AAYF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,gCAAgC,CAC7C,GAA2C,EAC3C,GAAmD,EACnD,KAAc,EACd,GAA6B,EAC7B,EAAE,2BAA2B,EAA2B;IAExD,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAA,gCAAa,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;QACvD,OAAO,GAAG,CAAC,IAAA,sBAAa,EAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,MAAM,CAAC,oBAAoB,CAAC,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,kBAAkB,CAAC,GAAG,MAAM,2BAA2B,CAC5D,oBAAoB,CACrB,CAAC;IAEF,8DAA8D;IAC9D,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAC/C,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import { isPlainObject } from '@metamask/controller-utils';\nimport type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { invalidParams } from '../errors';\nimport type { PermissionConstraint, RequestedPermissions } from '../Permission';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const requestPermissionsHandler: PermittedHandlerExport<\n  RequestPermissionsHooks,\n  [RequestedPermissions],\n  PermissionConstraint[]\n> = {\n  methodNames: [MethodNames.RequestPermissions],\n  implementation: requestPermissionsImplementation,\n  hookNames: {\n    requestPermissionsForOrigin: true,\n  },\n};\n\ntype RequestPermissions = (\n  requestedPermissions: RequestedPermissions,\n) => Promise<\n  [Record<string, PermissionConstraint>, { id: string; origin: string }]\n>;\n\nexport type RequestPermissionsHooks = {\n  requestPermissionsForOrigin: RequestPermissions;\n};\n\n/**\n * Request Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param req - The JsonRpcEngine request\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.requestPermissionsForOrigin - The specific method hook needed for this method implementation\n * @returns A promise that resolves to nothing\n */\nasync function requestPermissionsImplementation(\n  req: JsonRpcRequest<[RequestedPermissions]>,\n  res: PendingJsonRpcResponse<PermissionConstraint[]>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { requestPermissionsForOrigin }: RequestPermissionsHooks,\n): Promise<void> {\n  const { params } = req;\n\n  if (!Array.isArray(params) || !isPlainObject(params[0])) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  const [requestedPermissions] = params;\n  const [grantedPermissions] = await requestPermissionsForOrigin(\n    requestedPermissions,\n  );\n\n  // `wallet_requestPermission` is specified to return an array.\n  res.result = Object.values(grantedPermissions);\n  return end();\n}\n"]}

package/dist/{types/rpc-methods/requestPermissions.d.ts → rpc-methods/requestPermissions.d.cts}

@@ -1,5 +1,5 @@
-import type { PermissionConstraint, RequestedPermissions } from '../Permission';
-import type { PermittedHandlerExport } from '../utils';
+import type { PermissionConstraint, RequestedPermissions } from "../Permission.cjs";
+import type { PermittedHandlerExport } from "../utils.cjs";
 export declare const requestPermissionsHandler: PermittedHandlerExport<RequestPermissionsHooks, [
     RequestedPermissions
 ], PermissionConstraint[]>;
@@ -14,4 +14,4 @@ export type RequestPermissionsHooks = {
     requestPermissionsForOrigin: RequestPermissions;
 };
 export {};
-//# sourceMappingURL=requestPermissions.d.ts.map
+//# sourceMappingURL=requestPermissions.d.cts.map

package/dist/rpc-methods/requestPermissions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestPermissions.d.cts","sourceRoot":"","sources":["../../src/rpc-methods/requestPermissions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,0BAAsB;AAChF,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,yBAAyB,EAAE,sBAAsB,CAC5D,uBAAuB,EACvB;IAAC,oBAAoB;CAAC,EACtB,oBAAoB,EAAE,CAOvB,CAAC;AAEF,KAAK,kBAAkB,GAAG,CACxB,oBAAoB,EAAE,oBAAoB,KACvC,OAAO,CACV;IAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CAAC,CACvE,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,2BAA2B,EAAE,kBAAkB,CAAC;CACjD,CAAC"}

package/dist/rpc-methods/requestPermissions.d.mts

@@ -0,0 +1,17 @@
+import type { PermissionConstraint, RequestedPermissions } from "../Permission.mjs";
+import type { PermittedHandlerExport } from "../utils.mjs";
+export declare const requestPermissionsHandler: PermittedHandlerExport<RequestPermissionsHooks, [
+    RequestedPermissions
+], PermissionConstraint[]>;
+type RequestPermissions = (requestedPermissions: RequestedPermissions) => Promise<[
+    Record<string, PermissionConstraint>,
+    {
+        id: string;
+        origin: string;
+    }
+]>;
+export type RequestPermissionsHooks = {
+    requestPermissionsForOrigin: RequestPermissions;
+};
+export {};
+//# sourceMappingURL=requestPermissions.d.mts.map

package/dist/rpc-methods/requestPermissions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestPermissions.d.mts","sourceRoot":"","sources":["../../src/rpc-methods/requestPermissions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,0BAAsB;AAChF,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,yBAAyB,EAAE,sBAAsB,CAC5D,uBAAuB,EACvB;IAAC,oBAAoB;CAAC,EACtB,oBAAoB,EAAE,CAOvB,CAAC;AAEF,KAAK,kBAAkB,GAAG,CACxB,oBAAoB,EAAE,oBAAoB,KACvC,OAAO,CACV;IAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CAAC,CACvE,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,2BAA2B,EAAE,kBAAkB,CAAC;CACjD,CAAC"}

package/dist/rpc-methods/requestPermissions.mjs

@@ -1,10 +1,33 @@
-import {
-  requestPermissionsHandler
-} from "../chunk-OCLNDUYO.mjs";
-import "../chunk-G4BWJ7EA.mjs";
-import "../chunk-4NAVRO44.mjs";
-import "../chunk-2L4QPE5A.mjs";
-export {
-  requestPermissionsHandler
+import { isPlainObject } from "@metamask/controller-utils";
+import { invalidParams } from "../errors.mjs";
+import { MethodNames } from "../utils.mjs";
+export const requestPermissionsHandler = {
+    methodNames: [MethodNames.RequestPermissions],
+    implementation: requestPermissionsImplementation,
+    hookNames: {
+        requestPermissionsForOrigin: true,
+    },
 };
+/**
+ * Request Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param req - The JsonRpcEngine request
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.requestPermissionsForOrigin - The specific method hook needed for this method implementation
+ * @returns A promise that resolves to nothing
+ */
+async function requestPermissionsImplementation(req, res, _next, end, { requestPermissionsForOrigin }) {
+    const { params } = req;
+    if (!Array.isArray(params) || !isPlainObject(params[0])) {
+        return end(invalidParams({ data: { request: req } }));
+    }
+    const [requestedPermissions] = params;
+    const [grantedPermissions] = await requestPermissionsForOrigin(requestedPermissions);
+    // `wallet_requestPermission` is specified to return an array.
+    res.result = Object.values(grantedPermissions);
+    return end();
+}
 //# sourceMappingURL=requestPermissions.mjs.map

package/dist/rpc-methods/requestPermissions.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"requestPermissions.mjs","sourceRoot":"","sources":["../../src/rpc-methods/requestPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mCAAmC;AAI3D,OAAO,EAAE,aAAa,EAAE,sBAAkB;AAG1C,OAAO,EAAE,WAAW,EAAE,qBAAiB;AAEvC,MAAM,CAAC,MAAM,yBAAyB,GAIlC;IACF,WAAW,EAAE,CAAC,WAAW,CAAC,kBAAkB,CAAC;IAC7C,cAAc,EAAE,gCAAgC;IAChD,SAAS,EAAE;QACT,2BAA2B,EAAE,IAAI;KAClC;CACF,CAAC;AAYF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,gCAAgC,CAC7C,GAA2C,EAC3C,GAAmD,EACnD,KAAc,EACd,GAA6B,EAC7B,EAAE,2BAA2B,EAA2B;IAExD,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;QACvD,OAAO,GAAG,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,MAAM,CAAC,oBAAoB,CAAC,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,kBAAkB,CAAC,GAAG,MAAM,2BAA2B,CAC5D,oBAAoB,CACrB,CAAC;IAEF,8DAA8D;IAC9D,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAC/C,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import { isPlainObject } from '@metamask/controller-utils';\nimport type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport type { JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { invalidParams } from '../errors';\nimport type { PermissionConstraint, RequestedPermissions } from '../Permission';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const requestPermissionsHandler: PermittedHandlerExport<\n  RequestPermissionsHooks,\n  [RequestedPermissions],\n  PermissionConstraint[]\n> = {\n  methodNames: [MethodNames.RequestPermissions],\n  implementation: requestPermissionsImplementation,\n  hookNames: {\n    requestPermissionsForOrigin: true,\n  },\n};\n\ntype RequestPermissions = (\n  requestedPermissions: RequestedPermissions,\n) => Promise<\n  [Record<string, PermissionConstraint>, { id: string; origin: string }]\n>;\n\nexport type RequestPermissionsHooks = {\n  requestPermissionsForOrigin: RequestPermissions;\n};\n\n/**\n * Request Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param req - The JsonRpcEngine request\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.requestPermissionsForOrigin - The specific method hook needed for this method implementation\n * @returns A promise that resolves to nothing\n */\nasync function requestPermissionsImplementation(\n  req: JsonRpcRequest<[RequestedPermissions]>,\n  res: PendingJsonRpcResponse<PermissionConstraint[]>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { requestPermissionsForOrigin }: RequestPermissionsHooks,\n): Promise<void> {\n  const { params } = req;\n\n  if (!Array.isArray(params) || !isPlainObject(params[0])) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  const [requestedPermissions] = params;\n  const [grantedPermissions] = await requestPermissionsForOrigin(\n    requestedPermissions,\n  );\n\n  // `wallet_requestPermission` is specified to return an array.\n  res.result = Object.values(grantedPermissions);\n  return end();\n}\n"]}

package/dist/rpc-methods/revokePermissions.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokePermissionsHandler = void 0;
+const utils_1 = require("@metamask/utils");
+const errors_1 = require("../errors.cjs");
+const utils_2 = require("../utils.cjs");
+exports.revokePermissionsHandler = {
+    methodNames: [utils_2.MethodNames.RevokePermissions],
+    implementation: revokePermissionsImplementation,
+    hookNames: {
+        revokePermissionsForOrigin: true,
+    },
+};
+/**
+ * Revoke Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param req - The JsonRpcEngine request
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.revokePermissionsForOrigin - A hook that revokes given permission keys for an origin
+ * @returns A promise that resolves to nothing
+ */
+async function revokePermissionsImplementation(req, res, _next, end, { revokePermissionsForOrigin }) {
+    const { params } = req;
+    const param = params?.[0];
+    if (!param) {
+        return end((0, errors_1.invalidParams)({ data: { request: req } }));
+    }
+    // For now, this API revokes the entire permission key
+    // even if caveats are specified.
+    const permissionKeys = Object.keys(param);
+    if (!(0, utils_1.isNonEmptyArray)(permissionKeys)) {
+        return end((0, errors_1.invalidParams)({ data: { request: req } }));
+    }
+    revokePermissionsForOrigin(permissionKeys);
+    res.result = null;
+    return end();
+}
+//# sourceMappingURL=revokePermissions.cjs.map

package/dist/rpc-methods/revokePermissions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"revokePermissions.cjs","sourceRoot":"","sources":["../../src/rpc-methods/revokePermissions.ts"],"names":[],"mappings":";;;AACA,2CAMyB;AAEzB,0CAA0C;AAG1C,wCAAuC;AAE1B,QAAA,wBAAwB,GAIjC;IACF,WAAW,EAAE,CAAC,mBAAW,CAAC,iBAAiB,CAAC;IAC5C,cAAc,EAAE,+BAA+B;IAC/C,SAAS,EAAE;QACT,0BAA0B,EAAE,IAAI;KACjC;CACF,CAAC;AAeF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,+BAA+B,CAC5C,GAAyC,EACzC,GAAiC,EACjC,KAAc,EACd,GAA6B,EAC7B,EAAE,0BAA0B,EAA0B;IAEtD,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAE1B,IAAI,CAAC,KAAK,EAAE;QACV,OAAO,GAAG,CAAC,IAAA,sBAAa,EAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,sDAAsD;IACtD,iCAAiC;IACjC,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAE1C,IAAI,CAAC,IAAA,uBAAe,EAAC,cAAc,CAAC,EAAE;QACpC,OAAO,GAAG,CAAC,IAAA,sBAAa,EAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,0BAA0B,CAAC,cAAc,CAAC,CAAC;IAE3C,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC;IAElB,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport {\n  isNonEmptyArray,\n  type Json,\n  type JsonRpcRequest,\n  type NonEmptyArray,\n  type PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport { invalidParams } from '../errors';\nimport type { PermissionConstraint } from '../Permission';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const revokePermissionsHandler: PermittedHandlerExport<\n  RevokePermissionsHooks,\n  RevokePermissionArgs,\n  null\n> = {\n  methodNames: [MethodNames.RevokePermissions],\n  implementation: revokePermissionsImplementation,\n  hookNames: {\n    revokePermissionsForOrigin: true,\n  },\n};\n\nexport type RevokePermissionArgs = Record<\n  PermissionConstraint['parentCapability'],\n  Json\n>;\n\ntype RevokePermissions = (\n  permissions: NonEmptyArray<PermissionConstraint['parentCapability']>,\n) => void;\n\nexport type RevokePermissionsHooks = {\n  revokePermissionsForOrigin: RevokePermissions;\n};\n\n/**\n * Revoke Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param req - The JsonRpcEngine request\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.revokePermissionsForOrigin - A hook that revokes given permission keys for an origin\n * @returns A promise that resolves to nothing\n */\nasync function revokePermissionsImplementation(\n  req: JsonRpcRequest<RevokePermissionArgs>,\n  res: PendingJsonRpcResponse<null>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { revokePermissionsForOrigin }: RevokePermissionsHooks,\n): Promise<void> {\n  const { params } = req;\n\n  const param = params?.[0];\n\n  if (!param) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  // For now, this API revokes the entire permission key\n  // even if caveats are specified.\n  const permissionKeys = Object.keys(param);\n\n  if (!isNonEmptyArray(permissionKeys)) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  revokePermissionsForOrigin(permissionKeys);\n\n  res.result = null;\n\n  return end();\n}\n"]}

package/dist/{types/rpc-methods/revokePermissions.d.ts → rpc-methods/revokePermissions.d.cts}

@@ -1,6 +1,6 @@
-import { type Json, type NonEmptyArray } from '@metamask/utils';
-import type { PermissionConstraint } from '../Permission';
-import type { PermittedHandlerExport } from '../utils';
+import { type Json, type NonEmptyArray } from "@metamask/utils";
+import type { PermissionConstraint } from "../Permission.cjs";
+import type { PermittedHandlerExport } from "../utils.cjs";
 export declare const revokePermissionsHandler: PermittedHandlerExport<RevokePermissionsHooks, RevokePermissionArgs, null>;
 export type RevokePermissionArgs = Record<PermissionConstraint['parentCapability'], Json>;
 type RevokePermissions = (permissions: NonEmptyArray<PermissionConstraint['parentCapability']>) => void;
@@ -8,4 +8,4 @@ export type RevokePermissionsHooks = {
     revokePermissionsForOrigin: RevokePermissions;
 };
 export {};
-//# sourceMappingURL=revokePermissions.d.ts.map
+//# sourceMappingURL=revokePermissions.d.cts.map

package/dist/rpc-methods/revokePermissions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revokePermissions.d.cts","sourceRoot":"","sources":["../../src/rpc-methods/revokePermissions.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,IAAI,EAET,KAAK,aAAa,EAEnB,wBAAwB;AAGzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAAsB;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,wBAAwB,EAAE,sBAAsB,CAC3D,sBAAsB,EACtB,oBAAoB,EACpB,IAAI,CAOL,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC,oBAAoB,CAAC,kBAAkB,CAAC,EACxC,IAAI,CACL,CAAC;AAEF,KAAK,iBAAiB,GAAG,CACvB,WAAW,EAAE,aAAa,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,KACjE,IAAI,CAAC;AAEV,MAAM,MAAM,sBAAsB,GAAG;IACnC,0BAA0B,EAAE,iBAAiB,CAAC;CAC/C,CAAC"}

package/dist/rpc-methods/revokePermissions.d.mts

@@ -0,0 +1,11 @@
+import { type Json, type NonEmptyArray } from "@metamask/utils";
+import type { PermissionConstraint } from "../Permission.mjs";
+import type { PermittedHandlerExport } from "../utils.mjs";
+export declare const revokePermissionsHandler: PermittedHandlerExport<RevokePermissionsHooks, RevokePermissionArgs, null>;
+export type RevokePermissionArgs = Record<PermissionConstraint['parentCapability'], Json>;
+type RevokePermissions = (permissions: NonEmptyArray<PermissionConstraint['parentCapability']>) => void;
+export type RevokePermissionsHooks = {
+    revokePermissionsForOrigin: RevokePermissions;
+};
+export {};
+//# sourceMappingURL=revokePermissions.d.mts.map

package/dist/rpc-methods/revokePermissions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revokePermissions.d.mts","sourceRoot":"","sources":["../../src/rpc-methods/revokePermissions.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,IAAI,EAET,KAAK,aAAa,EAEnB,wBAAwB;AAGzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAAsB;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAiB;AAGvD,eAAO,MAAM,wBAAwB,EAAE,sBAAsB,CAC3D,sBAAsB,EACtB,oBAAoB,EACpB,IAAI,CAOL,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC,oBAAoB,CAAC,kBAAkB,CAAC,EACxC,IAAI,CACL,CAAC;AAEF,KAAK,iBAAiB,GAAG,CACvB,WAAW,EAAE,aAAa,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,KACjE,IAAI,CAAC;AAEV,MAAM,MAAM,sBAAsB,GAAG;IACnC,0BAA0B,EAAE,iBAAiB,CAAC;CAC/C,CAAC"}

package/dist/rpc-methods/revokePermissions.mjs

@@ -1,10 +1,38 @@
-import {
-  revokePermissionsHandler
-} from "../chunk-74H4CVH7.mjs";
-import "../chunk-G4BWJ7EA.mjs";
-import "../chunk-4NAVRO44.mjs";
-import "../chunk-2L4QPE5A.mjs";
-export {
-  revokePermissionsHandler
+import { isNonEmptyArray } from "@metamask/utils";
+import { invalidParams } from "../errors.mjs";
+import { MethodNames } from "../utils.mjs";
+export const revokePermissionsHandler = {
+    methodNames: [MethodNames.RevokePermissions],
+    implementation: revokePermissionsImplementation,
+    hookNames: {
+        revokePermissionsForOrigin: true,
+    },
 };
+/**
+ * Revoke Permissions implementation to be used in JsonRpcEngine middleware.
+ *
+ * @param req - The JsonRpcEngine request
+ * @param res - The JsonRpcEngine result object
+ * @param _next - JsonRpcEngine next() callback - unused
+ * @param end - JsonRpcEngine end() callback
+ * @param options - Method hooks passed to the method implementation
+ * @param options.revokePermissionsForOrigin - A hook that revokes given permission keys for an origin
+ * @returns A promise that resolves to nothing
+ */
+async function revokePermissionsImplementation(req, res, _next, end, { revokePermissionsForOrigin }) {
+    const { params } = req;
+    const param = params?.[0];
+    if (!param) {
+        return end(invalidParams({ data: { request: req } }));
+    }
+    // For now, this API revokes the entire permission key
+    // even if caveats are specified.
+    const permissionKeys = Object.keys(param);
+    if (!isNonEmptyArray(permissionKeys)) {
+        return end(invalidParams({ data: { request: req } }));
+    }
+    revokePermissionsForOrigin(permissionKeys);
+    res.result = null;
+    return end();
+}
 //# sourceMappingURL=revokePermissions.mjs.map

package/dist/rpc-methods/revokePermissions.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"revokePermissions.mjs","sourceRoot":"","sources":["../../src/rpc-methods/revokePermissions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EAKhB,wBAAwB;AAEzB,OAAO,EAAE,aAAa,EAAE,sBAAkB;AAG1C,OAAO,EAAE,WAAW,EAAE,qBAAiB;AAEvC,MAAM,CAAC,MAAM,wBAAwB,GAIjC;IACF,WAAW,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC;IAC5C,cAAc,EAAE,+BAA+B;IAC/C,SAAS,EAAE;QACT,0BAA0B,EAAE,IAAI;KACjC;CACF,CAAC;AAeF;;;;;;;;;;GAUG;AACH,KAAK,UAAU,+BAA+B,CAC5C,GAAyC,EACzC,GAAiC,EACjC,KAAc,EACd,GAA6B,EAC7B,EAAE,0BAA0B,EAA0B;IAEtD,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IAEvB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAE1B,IAAI,CAAC,KAAK,EAAE;QACV,OAAO,GAAG,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,sDAAsD;IACtD,iCAAiC;IACjC,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAE1C,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE;QACpC,OAAO,GAAG,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;KACvD;IAED,0BAA0B,CAAC,cAAc,CAAC,CAAC;IAE3C,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC;IAElB,OAAO,GAAG,EAAE,CAAC;AACf,CAAC","sourcesContent":["import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';\nimport {\n  isNonEmptyArray,\n  type Json,\n  type JsonRpcRequest,\n  type NonEmptyArray,\n  type PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport { invalidParams } from '../errors';\nimport type { PermissionConstraint } from '../Permission';\nimport type { PermittedHandlerExport } from '../utils';\nimport { MethodNames } from '../utils';\n\nexport const revokePermissionsHandler: PermittedHandlerExport<\n  RevokePermissionsHooks,\n  RevokePermissionArgs,\n  null\n> = {\n  methodNames: [MethodNames.RevokePermissions],\n  implementation: revokePermissionsImplementation,\n  hookNames: {\n    revokePermissionsForOrigin: true,\n  },\n};\n\nexport type RevokePermissionArgs = Record<\n  PermissionConstraint['parentCapability'],\n  Json\n>;\n\ntype RevokePermissions = (\n  permissions: NonEmptyArray<PermissionConstraint['parentCapability']>,\n) => void;\n\nexport type RevokePermissionsHooks = {\n  revokePermissionsForOrigin: RevokePermissions;\n};\n\n/**\n * Revoke Permissions implementation to be used in JsonRpcEngine middleware.\n *\n * @param req - The JsonRpcEngine request\n * @param res - The JsonRpcEngine result object\n * @param _next - JsonRpcEngine next() callback - unused\n * @param end - JsonRpcEngine end() callback\n * @param options - Method hooks passed to the method implementation\n * @param options.revokePermissionsForOrigin - A hook that revokes given permission keys for an origin\n * @returns A promise that resolves to nothing\n */\nasync function revokePermissionsImplementation(\n  req: JsonRpcRequest<RevokePermissionArgs>,\n  res: PendingJsonRpcResponse<null>,\n  _next: unknown,\n  end: JsonRpcEngineEndCallback,\n  { revokePermissionsForOrigin }: RevokePermissionsHooks,\n): Promise<void> {\n  const { params } = req;\n\n  const param = params?.[0];\n\n  if (!param) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  // For now, this API revokes the entire permission key\n  // even if caveats are specified.\n  const permissionKeys = Object.keys(param);\n\n  if (!isNonEmptyArray(permissionKeys)) {\n    return end(invalidParams({ data: { request: req } }));\n  }\n\n  revokePermissionsForOrigin(permissionKeys);\n\n  res.result = null;\n\n  return end();\n}\n"]}

package/dist/utils.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUniqueAndPairedCaveats = exports.MethodNames = void 0;
+var MethodNames;
+(function (MethodNames) {
+    MethodNames["RequestPermissions"] = "wallet_requestPermissions";
+    MethodNames["GetPermissions"] = "wallet_getPermissions";
+    MethodNames["RevokePermissions"] = "wallet_revokePermissions";
+})(MethodNames || (exports.MethodNames = MethodNames = {}));
+/**
+ * Given two permission objects, computes 3 sets:
+ * - The set of caveat pairs that are common to both permissions.
+ * - The set of caveats that are unique to the existing permission.
+ * - The set of caveats that are unique to the requested permission.
+ *
+ * Assumes that the caveat arrays of both permissions are valid.
+ *
+ * @param leftPermission - The left-hand permission.
+ * @param rightPermission - The right-hand permission.
+ * @returns The sets of caveat pairs and unique caveats.
+ */
+function collectUniqueAndPairedCaveats(leftPermission, rightPermission) {
+    const leftCaveats = leftPermission?.caveats?.slice() ?? [];
+    const rightCaveats = rightPermission.caveats?.slice() ?? [];
+    const leftUniqueCaveats = [];
+    const caveatPairs = [];
+    leftCaveats.forEach((leftCaveat) => {
+        const rightCaveatIndex = rightCaveats.findIndex((rightCaveat) => rightCaveat.type === leftCaveat.type);
+        if (rightCaveatIndex === -1) {
+            leftUniqueCaveats.push(leftCaveat);
+        }
+        else {
+            caveatPairs.push([leftCaveat, rightCaveats[rightCaveatIndex]]);
+            rightCaveats.splice(rightCaveatIndex, 1);
+        }
+    });
+    return {
+        caveatPairs,
+        leftUniqueCaveats,
+        rightUniqueCaveats: [...rightCaveats],
+    };
+}
+exports.collectUniqueAndPairedCaveats = collectUniqueAndPairedCaveats;
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;;AAsBA,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,+DAAgD,CAAA;IAChD,uDAAwC,CAAA;IACxC,6DAA8C,CAAA;AAChD,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB;AAsDD;;;;;;;;;;;GAWG;AACH,SAAgB,6BAA6B,CAC3C,cAAyD,EACzD,eAA8C;IAE9C,MAAM,WAAW,GAAG,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC3D,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC5D,MAAM,iBAAiB,GAAuB,EAAE,CAAC;IACjD,MAAM,WAAW,GAA2C,EAAE,CAAC;IAE/D,WAAW,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;QACjC,MAAM,gBAAgB,GAAG,YAAY,CAAC,SAAS,CAC7C,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,CACtD,CAAC;QAEF,IAAI,gBAAgB,KAAK,CAAC,CAAC,EAAE;YAC3B,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SACpC;aAAM;YACL,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAC/D,YAAY,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;SAC1C;IACH,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,WAAW;QACX,iBAAiB;QACjB,kBAAkB,EAAE,CAAC,GAAG,YAAY,CAAC;KACtC,CAAC;AACJ,CAAC;AA3BD,sEA2BC","sourcesContent":["import type {\n  JsonRpcEngineEndCallback,\n  JsonRpcEngineNextCallback,\n} from '@metamask/json-rpc-engine';\nimport type {\n  Json,\n  JsonRpcParams,\n  JsonRpcRequest,\n  PendingJsonRpcResponse,\n} from '@metamask/utils';\n\nimport type {\n  CaveatConstraint,\n  CaveatSpecificationConstraint,\n  CaveatSpecificationMap,\n} from './Caveat';\nimport type {\n  PermissionConstraint,\n  PermissionSpecificationConstraint,\n  PermissionSpecificationMap,\n} from './Permission';\n\nexport enum MethodNames {\n  RequestPermissions = 'wallet_requestPermissions',\n  GetPermissions = 'wallet_getPermissions',\n  RevokePermissions = 'wallet_revokePermissions',\n}\n\n/**\n * Utility type for extracting a union of all individual caveat or permission\n * specification types from a {@link CaveatSpecificationMap} or\n * {@link PermissionSpecificationMap}.\n *\n * @template SpecificationsMap - The caveat or permission specifications map\n * whose specification type union to extract.\n */\nexport type ExtractSpecifications<\n  SpecificationsMap extends\n    | CaveatSpecificationMap<CaveatSpecificationConstraint>\n    | PermissionSpecificationMap<PermissionSpecificationConstraint>,\n> = SpecificationsMap[keyof SpecificationsMap];\n\n/**\n * A middleware function for handling a permitted method.\n */\nexport type HandlerMiddlewareFunction<\n  Hooks,\n  Params extends JsonRpcParams,\n  Result extends Json,\n> = (\n  req: JsonRpcRequest<Params>,\n  res: PendingJsonRpcResponse<Result>,\n  next: JsonRpcEngineNextCallback,\n  end: JsonRpcEngineEndCallback,\n  hooks: Hooks,\n) => void | Promise<void>;\n\n/**\n * We use a mapped object type in order to create a type that requires the\n * presence of the names of all hooks for the given handler.\n * This can then be used to select only the necessary hooks whenever a method\n * is called for purposes of POLA.\n */\nexport type HookNames<HookMap> = {\n  [Property in keyof HookMap]: true;\n};\n\n/**\n * A handler for a permitted method.\n */\nexport type PermittedHandlerExport<\n  Hooks,\n  Params extends JsonRpcParams,\n  Result extends Json,\n> = {\n  implementation: HandlerMiddlewareFunction<Hooks, Params, Result>;\n  hookNames: HookNames<Hooks>;\n  methodNames: string[];\n};\n\n/**\n * Given two permission objects, computes 3 sets:\n * - The set of caveat pairs that are common to both permissions.\n * - The set of caveats that are unique to the existing permission.\n * - The set of caveats that are unique to the requested permission.\n *\n * Assumes that the caveat arrays of both permissions are valid.\n *\n * @param leftPermission - The left-hand permission.\n * @param rightPermission - The right-hand permission.\n * @returns The sets of caveat pairs and unique caveats.\n */\nexport function collectUniqueAndPairedCaveats(\n  leftPermission: Partial<PermissionConstraint> | undefined,\n  rightPermission: Partial<PermissionConstraint>,\n) {\n  const leftCaveats = leftPermission?.caveats?.slice() ?? [];\n  const rightCaveats = rightPermission.caveats?.slice() ?? [];\n  const leftUniqueCaveats: CaveatConstraint[] = [];\n  const caveatPairs: [CaveatConstraint, CaveatConstraint][] = [];\n\n  leftCaveats.forEach((leftCaveat) => {\n    const rightCaveatIndex = rightCaveats.findIndex(\n      (rightCaveat) => rightCaveat.type === leftCaveat.type,\n    );\n\n    if (rightCaveatIndex === -1) {\n      leftUniqueCaveats.push(leftCaveat);\n    } else {\n      caveatPairs.push([leftCaveat, rightCaveats[rightCaveatIndex]]);\n      rightCaveats.splice(rightCaveatIndex, 1);\n    }\n  });\n\n  return {\n    caveatPairs,\n    leftUniqueCaveats,\n    rightUniqueCaveats: [...rightCaveats],\n  };\n}\n"]}