@metamask-previews/gator-permissions-controller 1.1.2-preview-e8f4442d4 → 1.1.2-preview-27e39dd44

package/CHANGELOG.md

@@ -9,12 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **BREAKING:** Refactor `GatorPermissionsController`: simplified config, permission storage, and public API ([#7847](https://github.com/MetaMask/core/pull/7847))
-  - Constructor now requires `config`, internal configuration is removed from controller state
-  - New `initialize()` function performs a syncronisation process if required when the controller is first initialized
-  - Replaces `gatorPermissionsMapSerialized` with `grantedPermissions` property in internal state, replaces related types, and utility functions
-  - `fetchAndUpdateGatorPermissions()` no longer accepts parameters and resolves to `void`
-  - `getPendingRevocations` / `pendingRevocations` getter replaced by `isPendingRevocation(permissionContext)`; list on `state.pendingRevocations`
 - Bump `@metamask/transaction-controller` from `^62.11.0` to `^62.17.0` ([#7775](https://github.com/MetaMask/core/pull/7775), [#7802](https://github.com/MetaMask/core/pull/7802), [#7832](https://github.com/MetaMask/core/pull/7832), [#7854](https://github.com/MetaMask/core/pull/7854), [#7872](https://github.com/MetaMask/core/pull/7872)), ([#7897](https://github.com/MetaMask/core/pull/7897))
 
 ## [1.1.2]

package/README.md

@@ -17,21 +17,13 @@ or
 ```typescript
 import { GatorPermissionsController } from '@metamask/gator-permissions-controller';
 
-// Create the controller with required config
+// Create the controller
 const gatorPermissionsController = new GatorPermissionsController({
   messenger: yourMessenger,
-  config: {
-    supportedPermissionTypes: [
-      'native-token-stream',
-      'native-token-periodic',
-      'erc20-token-stream',
-      'erc20-token-periodic',
-      'erc20-token-revocation',
-    ],
-    // Optional: override the default gator permissions provider Snap id
-    // gatorPermissionsProviderSnapId: 'npm:@metamask/gator-permissions-snap',
-  },
 });
+
+// Enable the feature (requires authentication)
+gatorPermissionsController.enableGatorPermissions();
 ```
 
 ### Fetch from Profile Sync
@@ -41,9 +33,12 @@ const gatorPermissionsController = new GatorPermissionsController({
 const permissions =
   await gatorPermissionsController.fetchAndUpdateGatorPermissions();
 
-// Fetch permissions and update internal state
-const permissions =
-  await gatorPermissionsController.fetchAndUpdateGatorPermissions();
+// Fetch permissions with optional filter params
+const filteredPermissions =
+  await gatorPermissionsController.fetchAndUpdateGatorPermissions({
+    origin: 'https://example.com',
+    chainId: '0x1',
+  });
 ```
 
 ## Contributing

package/dist/GatorPermissionsController.cjs

@@ -4,14 +4,9 @@ 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 __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 _GatorPermissionsController_instances, _GatorPermissionsController_supportedPermissionTypes, _GatorPermissionsController_gatorPermissionsProviderSnapId, _GatorPermissionsController_maxSyncIntervalMs, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, _GatorPermissionsController_setIsFetchingGatorPermissions, _GatorPermissionsController_addPendingRevocationToState, _GatorPermissionsController_removePendingRevocationFromStateByTxId, _GatorPermissionsController_removePendingRevocationFromStateByPermissionContext, _GatorPermissionsController_registerMessageHandlers, _GatorPermissionsController_storedPermissionToPermissionInfo, _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata;
+var _GatorPermissionsController_instances, _GatorPermissionsController_setIsFetchingGatorPermissions, _GatorPermissionsController_setIsGatorPermissionsEnabled, _GatorPermissionsController_addPendingRevocationToState, _GatorPermissionsController_removePendingRevocationFromStateByTxId, _GatorPermissionsController_removePendingRevocationFromStateByPermissionContext, _GatorPermissionsController_registerMessageHandlers, _GatorPermissionsController_assertGatorPermissionsEnabled, _GatorPermissionsController_handleSnapRequestToGatorPermissionsProvider, _GatorPermissionsController_sanitizeStoredGatorPermission, _GatorPermissionsController_categorizePermissionsDataByTypeAndChainId;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultGatorPermissionsControllerState = void 0;
 const base_controller_1 = require("@metamask/base-controller");
 const delegation_deployments_1 = require("@metamask/delegation-deployments");
 const snaps_utils_1 = require("@metamask/snaps-utils");
@@ -27,7 +22,16 @@ const utils_1 = require("./utils.cjs");
 const controllerName = 'GatorPermissionsController';
 // Default value for the gator permissions provider snap id
 const defaultGatorPermissionsProviderSnapId = 'npm:@metamask/gator-permissions-snap';
-const DEFAULT_MAX_SYNC_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days in milliseconds
+const createEmptyGatorPermissionsMap = () => {
+    return {
+        'erc20-token-revocation': {},
+        'native-token-stream': {},
+        'native-token-periodic': {},
+        'erc20-token-stream': {},
+        'erc20-token-periodic': {},
+        other: {},
+    };
+};
 /**
  * Timeout duration for pending revocations (2 hours in milliseconds).
  * After this time, event listeners will be cleaned up to prevent memory leaks.
@@ -35,7 +39,13 @@ const DEFAULT_MAX_SYNC_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days in mil
 const PENDING_REVOCATION_TIMEOUT = 2 * 60 * 60 * 1000;
 const contractsByChainId = delegation_deployments_1.DELEGATOR_CONTRACTS[constants_1.DELEGATION_FRAMEWORK_VERSION];
 const gatorPermissionsControllerMetadata = {
-    grantedPermissions: {
+    isGatorPermissionsEnabled: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    gatorPermissionsMapSerialized: {
         includeInStateLogs: true,
         persist: true,
         includeInDebugSnapshot: false,
@@ -45,149 +55,134 @@ const gatorPermissionsControllerMetadata = {
         includeInStateLogs: true,
         persist: false,
         includeInDebugSnapshot: false,
-        usedInUi: true,
+        usedInUi: false,
     },
-    pendingRevocations: {
+    gatorPermissionsProviderSnapId: {
         includeInStateLogs: true,
         persist: false,
         includeInDebugSnapshot: false,
-        usedInUi: true,
+        usedInUi: false,
     },
-    lastSyncedTimestamp: {
+    pendingRevocations: {
         includeInStateLogs: true,
-        persist: true,
+        persist: false,
         includeInDebugSnapshot: false,
-        usedInUi: false,
+        usedInUi: true,
     },
 };
 /**
- * Creates initial controller state, merging defaults with optional partial state.
- * Internal use only (e.g. constructor, tests).
+ * Constructs the default {@link GatorPermissionsController} state. This allows
+ * consumers to provide a partial state object when initializing the controller
+ * and also helps in constructing complete state objects for this controller in
+ * tests.
  *
- * @param state - Optional partial state to merge with defaults.
- * @returns Complete {@link GatorPermissionsController} state.
+ * @returns The default {@link GatorPermissionsController} state.
  */
-function createGatorPermissionsControllerState(state) {
+function getDefaultGatorPermissionsControllerState() {
     return {
-        grantedPermissions: [],
-        pendingRevocations: [],
-        lastSyncedTimestamp: -1,
-        ...state,
-        // isFetchingGatorPermissions is _always_ false when the controller is created
+        isGatorPermissionsEnabled: false,
+        gatorPermissionsMapSerialized: (0, utils_1.serializeGatorPermissionsMap)(createEmptyGatorPermissionsMap()),
         isFetchingGatorPermissions: false,
+        gatorPermissionsProviderSnapId: defaultGatorPermissionsProviderSnapId,
+        pendingRevocations: [],
     };
 }
+exports.getDefaultGatorPermissionsControllerState = getDefaultGatorPermissionsControllerState;
 /**
- * Controller that manages gator permissions by reading from the gator permissions provider Snap.
+ * Controller that manages gator permissions by reading from profile sync
  */
 class GatorPermissionsController extends base_controller_1.BaseController {
-    /**
-     * The Snap ID of the gator permissions provider.
-     *
-     * @returns The Snap ID of the gator permissions provider.
-     */
-    get gatorPermissionsProviderSnapId() {
-        return __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f");
-    }
     /**
      * Creates a GatorPermissionsController instance.
      *
      * @param args - The arguments to this function.
-     * @param args.messenger - Messenger used to communicate with other controllers.
-     * @param args.config - Configuration (supported permission types and optional Snap id).
-     * @param args.state - Optional partial state to merge with defaults.
+     * @param args.messenger - Messenger used to communicate with BaseV2 controller.
+     * @param args.state - Initial state to set on this controller.
      */
-    constructor({ messenger, config, state, }) {
-        const initialState = createGatorPermissionsControllerState(state);
+    constructor({ messenger, state, }) {
         super({
             name: controllerName,
             metadata: gatorPermissionsControllerMetadata,
             messenger,
-            state: initialState,
+            state: {
+                ...getDefaultGatorPermissionsControllerState(),
+                ...state,
+                isFetchingGatorPermissions: false,
+            },
         });
         _GatorPermissionsController_instances.add(this);
-        _GatorPermissionsController_supportedPermissionTypes.set(this, void 0);
-        _GatorPermissionsController_gatorPermissionsProviderSnapId.set(this, void 0);
-        _GatorPermissionsController_maxSyncIntervalMs.set(this, void 0);
-        /**
-         * When a sync is in progress, holds the promise for that sync so concurrent
-         * callers receive the same promise. Cleared when the sync completes.
-         */
-        _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise.set(this, null);
-        __classPrivateFieldSet(this, _GatorPermissionsController_supportedPermissionTypes, config.supportedPermissionTypes, "f");
-        __classPrivateFieldSet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, config.gatorPermissionsProviderSnapId ??
-            defaultGatorPermissionsProviderSnapId, "f");
-        __classPrivateFieldSet(this, _GatorPermissionsController_maxSyncIntervalMs, config.maxSyncIntervalMs ?? DEFAULT_MAX_SYNC_INTERVAL_MS, "f");
         __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_registerMessageHandlers).call(this);
     }
     /**
-     * Supported permission types this controller was configured with.
+     * Gets the gator permissions map from the state.
      *
-     * @returns The supported permission types.
+     * @returns The gator permissions map.
      */
-    get supportedPermissionTypes() {
-        return __classPrivateFieldGet(this, _GatorPermissionsController_supportedPermissionTypes, "f");
+    get gatorPermissionsMap() {
+        return (0, utils_1.deserializeGatorPermissionsMap)(this.state.gatorPermissionsMapSerialized);
     }
     /**
-     * Fetches granted permissions from the gator permissions provider Snap and updates state.
-     * If a sync is already in progress, returns the same promise. After the sync completes,
-     * the next call will perform a new sync.
+     * Gets the gator permissions provider snap id that is used to fetch gator permissions.
      *
-     * @returns A promise that resolves when the sync completes. All data is available via the controller's state.
-     * @throws {GatorPermissionsFetchError} If the gator permissions fetch fails.
+     * @returns The gator permissions provider snap id.
      */
-    fetchAndUpdateGatorPermissions() {
-        if (__classPrivateFieldGet(this, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, "f") !== null) {
-            return __classPrivateFieldGet(this, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, "f");
-        }
-        const performFetchAndUpdate = async () => {
-            try {
-                __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_setIsFetchingGatorPermissions).call(this, true);
-                // Only ever fetch non-revoked permissions. Revoked permissions may be
-                // left in storage by the gator permissions snap, but we don't need to
-                // fetch them.
-                const params = { isRevoked: false };
-                const permissionsData = await (0, utils_1.executeSnapRpc)({
-                    messenger: this.messenger,
-                    snapId: __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f"),
-                    method: types_1.GatorPermissionsSnapRpcMethod.PermissionProviderGetGrantedPermissions,
-                    params,
-                });
-                const grantedPermissions = __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata).call(this, permissionsData);
-                this.update((state) => {
-                    state.grantedPermissions = grantedPermissions;
-                    state.lastSyncedTimestamp = Date.now();
-                });
-            }
-            catch (error) {
-                (0, logger_1.controllerLog)('Failed to fetch gator permissions', error);
-                throw new errors_1.GatorPermissionsFetchError({
-                    message: 'Failed to fetch gator permissions',
-                    cause: error,
-                });
-            }
-            finally {
-                __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_setIsFetchingGatorPermissions).call(this, false);
-                __classPrivateFieldSet(this, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, null, "f");
-            }
-        };
-        __classPrivateFieldSet(this, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, performFetchAndUpdate(), "f");
-        return __classPrivateFieldGet(this, _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise, "f");
+    get permissionsProviderSnapId() {
+        return this.state.gatorPermissionsProviderSnapId;
     }
     /**
-     * Initializes the controller. Call once after construction to ensure the
-     * controller is ready for use.
+     * Enables gator permissions for the user.
+     */
+    async enableGatorPermissions() {
+        __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_setIsGatorPermissionsEnabled).call(this, true);
+    }
+    /**
+     * Clears the gator permissions map and disables the feature.
+     */
+    async disableGatorPermissions() {
+        this.update((state) => {
+            state.isGatorPermissionsEnabled = false;
+            state.gatorPermissionsMapSerialized = (0, utils_1.serializeGatorPermissionsMap)(createEmptyGatorPermissionsMap());
+        });
+    }
+    /**
+     * Gets the pending revocations list.
      *
-     * @returns A promise that resolves when initialization is complete.
+     * @returns The pending revocations list.
      */
-    async initialize() {
-        const currentTime = Date.now();
-        const millisecondsSinceLastSync = currentTime - this.state.lastSyncedTimestamp;
-        // Sync only when we have no data or data is stale, to avoid excessive startup
-        // queries while still avoiding showing stale data while a refresh runs.
-        if (this.state.lastSyncedTimestamp === -1 ||
-            millisecondsSinceLastSync > __classPrivateFieldGet(this, _GatorPermissionsController_maxSyncIntervalMs, "f")) {
-            await this.fetchAndUpdateGatorPermissions();
+    get pendingRevocations() {
+        return this.state.pendingRevocations;
+    }
+    /**
+     * Fetches the gator permissions from profile sync and updates the state.
+     *
+     * @param params - Optional parameters to pass to the snap's getGrantedPermissions method.
+     * @returns A promise that resolves to the gator permissions map.
+     * @throws {GatorPermissionsFetchError} If the gator permissions fetch fails.
+     */
+    async fetchAndUpdateGatorPermissions(params) {
+        try {
+            __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_setIsFetchingGatorPermissions).call(this, true);
+            __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_assertGatorPermissionsEnabled).call(this);
+            const permissionsData = await __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_handleSnapRequestToGatorPermissionsProvider).call(this, {
+                snapId: this.state.gatorPermissionsProviderSnapId,
+                params,
+            });
+            const gatorPermissionsMap = __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_categorizePermissionsDataByTypeAndChainId).call(this, permissionsData);
+            this.update((state) => {
+                state.gatorPermissionsMapSerialized =
+                    (0, utils_1.serializeGatorPermissionsMap)(gatorPermissionsMap);
+            });
+            return gatorPermissionsMap;
+        }
+        catch (error) {
+            (0, logger_1.controllerLog)('Failed to fetch gator permissions', error);
+            throw new errors_1.GatorPermissionsFetchError({
+                message: 'Failed to fetch gator permissions',
+                cause: error,
+            });
+        }
+        finally {
+            __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_setIsFetchingGatorPermissions).call(this, false);
         }
     }
     /**
@@ -211,7 +206,7 @@ class GatorPermissionsController extends base_controller_1.BaseController {
      * or the enforcers/terms do not match a supported permission type.
      */
     decodePermissionFromPermissionContextForOrigin({ origin, chainId, delegation: { caveats, delegator, delegate, authority }, metadata: { justification, origin: specifiedOrigin }, }) {
-        if (origin !== __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f")) {
+        if (origin !== this.permissionsProviderSnapId) {
             throw new errors_1.OriginNotAllowedError({ origin });
         }
         const contracts = contractsByChainId[chainId];
@@ -253,14 +248,16 @@ class GatorPermissionsController extends base_controller_1.BaseController {
      *
      * @param revocationParams - The revocation parameters containing the permission context.
      * @returns A promise that resolves when the revocation is submitted successfully.
+     * @throws {GatorPermissionsNotEnabledError} If the gator permissions are not enabled.
      * @throws {GatorPermissionsProviderError} If the snap request fails.
      */
     async submitRevocation(revocationParams) {
         (0, logger_1.controllerLog)('submitRevocation method called', {
             permissionContext: revocationParams.permissionContext,
         });
+        __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_assertGatorPermissionsEnabled).call(this);
         const snapRequest = {
-            snapId: __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f"),
+            snapId: this.state.gatorPermissionsProviderSnapId,
             origin: 'metamask',
             handler: snaps_utils_1.HandlerType.OnRpcRequest,
             request: {
@@ -272,7 +269,7 @@ class GatorPermissionsController extends base_controller_1.BaseController {
         try {
             const result = await this.messenger.call('SnapController:handleRequest', snapRequest);
             // Refresh list first (permission removed from list)
-            await this.fetchAndUpdateGatorPermissions();
+            await this.fetchAndUpdateGatorPermissions({ isRevoked: false });
             (0, logger_1.controllerLog)('Successfully submitted revocation', {
                 permissionContext: revocationParams.permissionContext,
                 result,
@@ -328,6 +325,7 @@ class GatorPermissionsController extends base_controller_1.BaseController {
             txId,
             permissionContext,
         });
+        __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_assertGatorPermissionsEnabled).call(this);
         // Track handlers and timeout for cleanup
         const handlers = {
             approved: undefined,
@@ -339,7 +337,7 @@ class GatorPermissionsController extends base_controller_1.BaseController {
         };
         // Helper to refresh permissions after transaction state change
         const refreshPermissions = (context) => {
-            this.fetchAndUpdateGatorPermissions().catch((error) => {
+            this.fetchAndUpdateGatorPermissions({ isRevoked: false }).catch((error) => {
                 (0, logger_1.controllerLog)(`Failed to refresh permissions after ${context}`, {
                     txId,
                     permissionContext,
@@ -490,9 +488,11 @@ class GatorPermissionsController extends base_controller_1.BaseController {
      *
      * @param params - The revocation parameters containing the permission context.
      * @returns A promise that resolves when the revocation is submitted successfully.
+     * @throws {GatorPermissionsNotEnabledError} If the gator permissions are not enabled.
      * @throws {GatorPermissionsProviderError} If the snap request fails.
      */
     async submitDirectRevocation(params) {
+        __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_assertGatorPermissionsEnabled).call(this);
         // Use a placeholder txId that doesn't conflict with real transaction IDs
         const placeholderTxId = `no-tx-${params.permissionContext}`;
         // Add to pending revocations state first (disables UI button immediately)
@@ -507,15 +507,18 @@ class GatorPermissionsController extends base_controller_1.BaseController {
      * @returns `true` if the permission context is pending revocation, `false` otherwise.
      */
     isPendingRevocation(permissionContext) {
-        const requestedPermissionContextLowercase = permissionContext.toLowerCase();
         return this.state.pendingRevocations.some((pendingRevocation) => pendingRevocation.permissionContext.toLowerCase() ===
-            requestedPermissionContextLowercase);
+            permissionContext.toLowerCase());
     }
 }
-_GatorPermissionsController_supportedPermissionTypes = new WeakMap(), _GatorPermissionsController_gatorPermissionsProviderSnapId = new WeakMap(), _GatorPermissionsController_maxSyncIntervalMs = new WeakMap(), _GatorPermissionsController_fetchAndUpdateGatorPermissionsPromise = new WeakMap(), _GatorPermissionsController_instances = new WeakSet(), _GatorPermissionsController_setIsFetchingGatorPermissions = function _GatorPermissionsController_setIsFetchingGatorPermissions(isFetchingGatorPermissions) {
+_GatorPermissionsController_instances = new WeakSet(), _GatorPermissionsController_setIsFetchingGatorPermissions = function _GatorPermissionsController_setIsFetchingGatorPermissions(isFetchingGatorPermissions) {
     this.update((state) => {
         state.isFetchingGatorPermissions = isFetchingGatorPermissions;
     });
+}, _GatorPermissionsController_setIsGatorPermissionsEnabled = function _GatorPermissionsController_setIsGatorPermissionsEnabled(isGatorPermissionsEnabled) {
+    this.update((state) => {
+        state.isGatorPermissionsEnabled = isGatorPermissionsEnabled;
+    });
 }, _GatorPermissionsController_addPendingRevocationToState = function _GatorPermissionsController_addPendingRevocationToState(txId, permissionContext) {
     this.update((state) => {
         state.pendingRevocations = [
@@ -534,24 +537,74 @@ _GatorPermissionsController_supportedPermissionTypes = new WeakMap(), _GatorPerm
     });
 }, _GatorPermissionsController_registerMessageHandlers = function _GatorPermissionsController_registerMessageHandlers() {
     this.messenger.registerActionHandler(`${controllerName}:fetchAndUpdateGatorPermissions`, this.fetchAndUpdateGatorPermissions.bind(this));
+    this.messenger.registerActionHandler(`${controllerName}:enableGatorPermissions`, this.enableGatorPermissions.bind(this));
+    this.messenger.registerActionHandler(`${controllerName}:disableGatorPermissions`, this.disableGatorPermissions.bind(this));
     this.messenger.registerActionHandler(`${controllerName}:decodePermissionFromPermissionContextForOrigin`, this.decodePermissionFromPermissionContextForOrigin.bind(this));
     const submitRevocationAction = `${controllerName}:submitRevocation`;
     this.messenger.registerActionHandler(submitRevocationAction, this.submitRevocation.bind(this));
     this.messenger.registerActionHandler(`${controllerName}:addPendingRevocation`, this.addPendingRevocation.bind(this));
     this.messenger.registerActionHandler(`${controllerName}:submitDirectRevocation`, this.submitDirectRevocation.bind(this));
     this.messenger.registerActionHandler(`${controllerName}:isPendingRevocation`, this.isPendingRevocation.bind(this));
-}, _GatorPermissionsController_storedPermissionToPermissionInfo = function _GatorPermissionsController_storedPermissionToPermissionInfo(storedGatorPermission) {
-    const { permissionResponse: fullPermissionResponse } = storedGatorPermission;
-    const { dependencies: _dependencies, to: _to, ...permissionResponse } = fullPermissionResponse;
+}, _GatorPermissionsController_assertGatorPermissionsEnabled = function _GatorPermissionsController_assertGatorPermissionsEnabled() {
+    if (!this.state.isGatorPermissionsEnabled) {
+        throw new errors_1.GatorPermissionsNotEnabledError();
+    }
+}, _GatorPermissionsController_handleSnapRequestToGatorPermissionsProvider = 
+/**
+ * Forwards a Snap request to the SnapController.
+ *
+ * @param args - The request parameters.
+ * @param args.snapId - The ID of the Snap of the gator permissions provider snap.
+ * @param args.params - Optional parameters to pass to the snap method.
+ * @returns A promise that resolves with the gator permissions.
+ */
+async function _GatorPermissionsController_handleSnapRequestToGatorPermissionsProvider({ snapId, params, }) {
+    try {
+        const response = (await this.messenger.call('SnapController:handleRequest', {
+            snapId,
+            origin: 'metamask',
+            handler: snaps_utils_1.HandlerType.OnRpcRequest,
+            request: {
+                jsonrpc: '2.0',
+                method: types_1.GatorPermissionsSnapRpcMethod.PermissionProviderGetGrantedPermissions,
+                ...(params !== undefined && { params }),
+            },
+        }));
+        return response;
+    }
+    catch (error) {
+        (0, logger_1.controllerLog)('Failed to handle snap request to gator permissions provider', error);
+        throw new errors_1.GatorPermissionsProviderError({
+            method: types_1.GatorPermissionsSnapRpcMethod.PermissionProviderGetGrantedPermissions,
+            cause: error,
+        });
+    }
+}, _GatorPermissionsController_sanitizeStoredGatorPermission = function _GatorPermissionsController_sanitizeStoredGatorPermission(storedGatorPermission) {
+    const { permissionResponse } = storedGatorPermission;
+    const { dependencies, to, ...rest } = permissionResponse;
     return {
         ...storedGatorPermission,
-        permissionResponse,
+        permissionResponse: {
+            ...rest,
+        },
     };
-}, _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata = function _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata(storedGatorPermissions) {
+}, _GatorPermissionsController_categorizePermissionsDataByTypeAndChainId = function _GatorPermissionsController_categorizePermissionsDataByTypeAndChainId(storedGatorPermissions) {
+    const gatorPermissionsMap = createEmptyGatorPermissionsMap();
     if (!storedGatorPermissions) {
-        return [];
+        return gatorPermissionsMap;
+    }
+    for (const storedGatorPermission of storedGatorPermissions) {
+        const { permissionResponse: { permission: { type: permissionType }, chainId, }, } = storedGatorPermission;
+        const isPermissionTypeKnown = Object.prototype.hasOwnProperty.call(gatorPermissionsMap, permissionType);
+        const permissionTypeKey = isPermissionTypeKnown
+            ? permissionType
+            : 'other';
+        gatorPermissionsMap[permissionTypeKey][chainId] = [
+            ...(gatorPermissionsMap[permissionTypeKey][chainId] || []),
+            __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_sanitizeStoredGatorPermission).call(this, storedGatorPermission),
+        ];
     }
-    return storedGatorPermissions.map((storedPermission) => __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_storedPermissionToPermissionInfo).call(this, storedPermission));
+    return gatorPermissionsMap;
 };
 exports.default = GatorPermissionsController;
 //# sourceMappingURL=GatorPermissionsController.cjs.map