@metamask-previews/gator-permissions-controller 5.0.2-preview-4f4c98e → 5.0.2-preview-eb263b0ee

package/dist/GatorPermissionsController.cjs

@@ -0,0 +1,589 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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_buildPreviousStatusByContext, _GatorPermissionsController_getProviderForChainId, _GatorPermissionsController_updateGrantedPermissionsStatus, _GatorPermissionsController_storedPermissionToPermissionInfo, _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatorPermissionsController = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const snaps_utils_1 = require("@metamask/snaps-utils");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+const index_js_1 = require("./decodePermission/decoders/index.cjs");
+const enforcerAddresses_js_1 = require("./decodePermission/enforcerAddresses.cjs");
+const index_js_2 = require("./decodePermission/index.cjs");
+const errors_js_1 = require("./errors.cjs");
+const logger_js_1 = require("./logger.cjs");
+const permissionOnChainStatus_js_1 = require("./permissionOnChainStatus.cjs");
+const types_js_1 = require("./types.cjs");
+const utils_js_1 = require("./utils.cjs");
+// === GENERAL ===
+// Unique name for the controller
+const controllerName = 'GatorPermissionsController';
+const MESSENGER_EXPOSED_METHODS = [
+    'fetchAndUpdateGatorPermissions',
+    'initialize',
+    'decodePermissionFromPermissionContextForOrigin',
+    'submitRevocation',
+    'addPendingRevocation',
+    'submitDirectRevocation',
+    'isPendingRevocation',
+];
+// 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
+/**
+ * Timeout duration for pending revocations (2 hours in milliseconds).
+ * After this time, event listeners will be cleaned up to prevent memory leaks.
+ */
+const PENDING_REVOCATION_TIMEOUT = 2 * 60 * 60 * 1000;
+const gatorPermissionsControllerMetadata = {
+    grantedPermissions: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isFetchingGatorPermissions: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    pendingRevocations: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastSyncedTimestamp: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+};
+/**
+ * Creates initial controller state, merging defaults with optional partial state.
+ * Internal use only (e.g. constructor, tests).
+ *
+ * @param state - Optional partial state to merge with defaults.
+ * @returns Complete {@link GatorPermissionsController} state.
+ */
+function createGatorPermissionsControllerState(state) {
+    return {
+        grantedPermissions: [],
+        pendingRevocations: [],
+        lastSyncedTimestamp: -1,
+        ...state,
+        // isFetchingGatorPermissions is _always_ false when the controller is created
+        isFetchingGatorPermissions: false,
+    };
+}
+/**
+ * Controller that manages gator permissions by reading from the gator permissions provider Snap.
+ */
+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.
+     */
+    constructor({ messenger, config, state, }) {
+        const initialState = createGatorPermissionsControllerState(state);
+        super({
+            name: controllerName,
+            metadata: gatorPermissionsControllerMetadata,
+            messenger,
+            state: initialState,
+        });
+        _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");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    /**
+     * Supported permission types this controller was configured with.
+     *
+     * @returns The supported permission types.
+     */
+    get supportedPermissionTypes() {
+        return __classPrivateFieldGet(this, _GatorPermissionsController_supportedPermissionTypes, "f");
+    }
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    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_js_1.executeSnapRpc)({
+                    messenger: this.messenger,
+                    snapId: __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f"),
+                    method: types_js_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();
+                });
+                const grantedPermissionsWithStatus = await __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_updateGrantedPermissionsStatus).call(this, grantedPermissions);
+                this.update((state) => {
+                    state.grantedPermissions = grantedPermissionsWithStatus;
+                });
+            }
+            catch (error) {
+                (0, logger_js_1.controllerLog)('Failed to fetch gator permissions', error);
+                throw new errors_js_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");
+    }
+    /**
+     * Initializes the controller. Call once after construction to ensure the
+     * controller is ready for use.
+     *
+     * @returns A promise that resolves when initialization is complete.
+     */
+    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();
+        }
+    }
+    /**
+     * Decodes a permission context into a structured permission for a specific origin.
+     *
+     * This method validates the caller origin, decodes the provided `permissionContext`
+     * into delegations, identifies the permission type from the caveat enforcers,
+     * extracts the permission-specific data and expiry, and reconstructs a
+     * {@link DecodedPermission} containing chainId, account addresses, to, type and data.
+     *
+     * @param args - The arguments to this function.
+     * @param args.origin - The caller's origin; must match the configured permissions provider Snap id.
+     * @param args.chainId - Numeric EIP-155 chain id used for resolving enforcer contracts and encoding.
+     * @param args.delegation - delegation representing the permission.
+     * @param args.metadata - metadata included in the request.
+     * @param args.metadata.justification - the justification as specified in the request metadata.
+     * @param args.metadata.origin - the origin as specified in the request metadata.
+     *
+     * @returns A decoded permission object suitable for UI consumption and follow-up actions.
+     * @throws If the origin is not allowed, the context cannot be decoded into exactly one delegation,
+     * the enforcers do not match any supported permission type, no candidate type validates
+     * the caveat terms, or more than one permission type successfully validates
+     * (ambiguous delegation).
+     */
+    decodePermissionFromPermissionContextForOrigin({ origin, chainId, delegation: { caveats, delegator, delegate, authority }, metadata: { justification, origin: specifiedOrigin }, }) {
+        if (origin !== __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f")) {
+            throw new errors_js_1.OriginNotAllowedError({ origin });
+        }
+        const deploymentContracts = enforcerAddresses_js_1.delegationContractsByChainId[chainId];
+        try {
+            if (!deploymentContracts) {
+                throw new Error(`Contracts not found for chainId: ${chainId}`);
+            }
+            const contracts = (0, enforcerAddresses_js_1.toEnforcerAddressesByName)(deploymentContracts);
+            const enforcers = caveats.map((caveat) => caveat.enforcer);
+            const permissionDecoders = (0, index_js_1.createPermissionDecodersForContracts)(contracts);
+            // Every decoder where enforcer addresses match; multiple types may share the
+            // same caveat pattern and are disambiguated by validateAndDecodePermission.
+            const matchingDecoders = (0, index_js_2.findDecodersWithMatchingCaveatAddresses)({
+                enforcers,
+                permissionDecoders,
+            });
+            const { decoder: { permissionType }, expiry, data, rules, } = (0, index_js_2.selectUniqueDecoderAndDecodedPermission)({
+                candidateDecoders: matchingDecoders,
+                caveats,
+            });
+            const permission = (0, index_js_2.reconstructDecodedPermission)({
+                chainId,
+                permissionType,
+                delegator,
+                delegate,
+                authority,
+                expiry,
+                data,
+                justification,
+                rules,
+                specifiedOrigin,
+            });
+            return permission;
+        }
+        catch (error) {
+            throw new errors_js_1.PermissionDecodingError({
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Submits a revocation to the gator permissions provider snap.
+     *
+     * @param revocationParams - The revocation parameters containing the permission context.
+     * @returns A promise that resolves when the revocation is submitted successfully.
+     * @throws {GatorPermissionsProviderError} If the snap request fails.
+     */
+    async submitRevocation(revocationParams) {
+        (0, logger_js_1.controllerLog)('submitRevocation method called', {
+            permissionContext: revocationParams.permissionContext,
+        });
+        const snapRequest = {
+            snapId: __classPrivateFieldGet(this, _GatorPermissionsController_gatorPermissionsProviderSnapId, "f"),
+            origin: 'metamask',
+            handler: snaps_utils_1.HandlerType.OnRpcRequest,
+            request: {
+                jsonrpc: '2.0',
+                method: types_js_1.GatorPermissionsSnapRpcMethod.PermissionProviderSubmitRevocation,
+                params: revocationParams,
+            },
+        };
+        try {
+            const result = await this.messenger.call('SnapController:handleRequest', snapRequest);
+            // Refresh list first (permission removed from list)
+            await this.fetchAndUpdateGatorPermissions();
+            (0, logger_js_1.controllerLog)('Successfully submitted revocation', {
+                permissionContext: revocationParams.permissionContext,
+                result,
+            });
+        }
+        catch (error) {
+            // If it's a GatorPermissionsFetchError, revocation succeeded but refresh failed
+            if (error instanceof errors_js_1.GatorPermissionsFetchError) {
+                (0, logger_js_1.controllerLog)('Revocation submitted successfully but failed to refresh permissions list', {
+                    error,
+                    permissionContext: revocationParams.permissionContext,
+                });
+                // Wrap with a more specific message indicating revocation succeeded
+                throw new errors_js_1.GatorPermissionsFetchError({
+                    message: 'Failed to refresh permissions list after successful revocation',
+                    cause: error,
+                });
+            }
+            // Otherwise, revocation failed - wrap in provider error
+            (0, logger_js_1.controllerLog)('Failed to submit revocation', {
+                error,
+                permissionContext: revocationParams.permissionContext,
+            });
+            throw new errors_js_1.GatorPermissionsProviderError({
+                method: types_js_1.GatorPermissionsSnapRpcMethod.PermissionProviderSubmitRevocation,
+                cause: error,
+            });
+        }
+        finally {
+            __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_removePendingRevocationFromStateByPermissionContext).call(this, revocationParams.permissionContext);
+        }
+    }
+    /**
+     * Adds a pending revocation that will be submitted once the transaction is confirmed.
+     *
+     * This method sets up listeners for the user's approval/rejection decision and
+     * terminal transaction states (confirmed, failed, dropped). The flow is:
+     * 1. Wait for user to approve or reject the transaction
+     * 2. If approved, add to pending revocations state
+     * 3. If rejected, cleanup without adding to state
+     * 4. If confirmed, submit the revocation
+     * 5. If failed or dropped, cleanup
+     *
+     * Includes a timeout safety net to prevent memory leaks if the transaction never
+     * reaches a terminal state.
+     *
+     * @param params - The pending revocation parameters.
+     * @returns A promise that resolves when the listener is set up.
+     */
+    async addPendingRevocation(params) {
+        const { txId, permissionContext } = params;
+        (0, logger_js_1.controllerLog)('addPendingRevocation method called', {
+            txId,
+            permissionContext,
+        });
+        // Track handlers and timeout for cleanup
+        const handlers = {
+            approved: undefined,
+            rejected: undefined,
+            confirmed: undefined,
+            failed: undefined,
+            dropped: undefined,
+            timeoutId: undefined,
+        };
+        // Helper to refresh permissions after transaction state change
+        const refreshPermissions = (context) => {
+            this.fetchAndUpdateGatorPermissions().catch((error) => {
+                (0, logger_js_1.controllerLog)(`Failed to refresh permissions after ${context}`, {
+                    txId,
+                    permissionContext,
+                    error,
+                });
+            });
+        };
+        // Helper to unsubscribe from approval/rejection events after decision is made
+        const cleanupApprovalHandlers = () => {
+            if (handlers.approved) {
+                this.messenger.unsubscribe('TransactionController:transactionApproved', handlers.approved);
+                handlers.approved = undefined;
+            }
+            if (handlers.rejected) {
+                this.messenger.unsubscribe('TransactionController:transactionRejected', handlers.rejected);
+                handlers.rejected = undefined;
+            }
+        };
+        // Cleanup function to unsubscribe from all events and clear timeout
+        const cleanup = (txIdToRemove, removeFromState = true) => {
+            cleanupApprovalHandlers();
+            if (handlers.confirmed) {
+                this.messenger.unsubscribe('TransactionController:transactionConfirmed', handlers.confirmed);
+            }
+            if (handlers.failed) {
+                this.messenger.unsubscribe('TransactionController:transactionFailed', handlers.failed);
+            }
+            if (handlers.dropped) {
+                this.messenger.unsubscribe('TransactionController:transactionDropped', handlers.dropped);
+            }
+            if (handlers.timeoutId !== undefined) {
+                clearTimeout(handlers.timeoutId);
+            }
+            // Remove the pending revocation from the state (only if it was added)
+            if (removeFromState) {
+                __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_removePendingRevocationFromStateByTxId).call(this, txIdToRemove);
+            }
+        };
+        // Handle approved transaction - add to pending revocations state
+        handlers.approved = (payload) => {
+            if (payload.transactionMeta.id === txId) {
+                (0, logger_js_1.controllerLog)('Transaction approved by user, adding to pending revocations', {
+                    txId,
+                    permissionContext,
+                });
+                __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_addPendingRevocationToState).call(this, txId, permissionContext);
+                // Unsubscribe from approval/rejection events since decision is made
+                cleanupApprovalHandlers();
+            }
+        };
+        // Handle rejected transaction - cleanup without adding to state
+        handlers.rejected = (payload) => {
+            if (payload.transactionMeta.id === txId) {
+                (0, logger_js_1.controllerLog)('Transaction rejected by user, cleaning up listeners', {
+                    txId,
+                    permissionContext,
+                });
+                // Don't remove from state since it was never added
+                cleanup(payload.transactionMeta.id, false);
+            }
+        };
+        // Handle confirmed transaction - submit revocation
+        handlers.confirmed = (transactionMeta) => {
+            if (transactionMeta.id === txId) {
+                (0, logger_js_1.controllerLog)('Transaction confirmed, submitting revocation', {
+                    txId,
+                    permissionContext,
+                    txHash: transactionMeta.hash,
+                });
+                if (transactionMeta.status !== transaction_controller_1.TransactionStatus.confirmed) {
+                    (0, logger_js_1.controllerLog)('Transaction not confirmed, skipping revocation', {
+                        txId,
+                        permissionContext,
+                        status: transactionMeta.status,
+                    });
+                    cleanup(transactionMeta.id);
+                    refreshPermissions('transaction not confirmed');
+                    return;
+                }
+                const txHash = transactionMeta.hash;
+                if (txHash === undefined) {
+                    (0, logger_js_1.controllerLog)('Failed to resolve transaction hash after revocation transaction confirmed', {
+                        txId,
+                        permissionContext,
+                        error: new Error('Confirmed transaction is missing transaction hash'),
+                    });
+                }
+                this.submitRevocation({ permissionContext, txHash })
+                    .catch((error) => {
+                    (0, logger_js_1.controllerLog)('Failed to submit revocation after transaction confirmed', {
+                        txId,
+                        permissionContext,
+                        error,
+                    });
+                })
+                    .finally(() => refreshPermissions('transaction confirmed'));
+                cleanup(transactionMeta.id);
+            }
+        };
+        // Handle failed transaction - cleanup without submitting revocation
+        handlers.failed = (payload) => {
+            if (payload.transactionMeta.id === txId) {
+                (0, logger_js_1.controllerLog)('Transaction failed, cleaning up revocation listener', {
+                    txId,
+                    permissionContext,
+                    error: payload.error,
+                });
+                cleanup(payload.transactionMeta.id);
+                refreshPermissions('transaction failed');
+            }
+        };
+        // Handle dropped transaction - cleanup without submitting revocation
+        handlers.dropped = (payload) => {
+            if (payload.transactionMeta.id === txId) {
+                (0, logger_js_1.controllerLog)('Transaction dropped, cleaning up revocation listener', {
+                    txId,
+                    permissionContext,
+                });
+                cleanup(payload.transactionMeta.id);
+                refreshPermissions('transaction dropped');
+            }
+        };
+        // Subscribe to user approval/rejection events
+        this.messenger.subscribe('TransactionController:transactionApproved', handlers.approved);
+        this.messenger.subscribe('TransactionController:transactionRejected', handlers.rejected);
+        // Subscribe to terminal transaction events
+        this.messenger.subscribe('TransactionController:transactionConfirmed', handlers.confirmed);
+        this.messenger.subscribe('TransactionController:transactionFailed', handlers.failed);
+        this.messenger.subscribe('TransactionController:transactionDropped', handlers.dropped);
+        // Set timeout as safety net to prevent memory leaks
+        handlers.timeoutId = setTimeout(() => {
+            (0, logger_js_1.controllerLog)('Pending revocation timed out, cleaning up listeners', {
+                txId,
+                permissionContext,
+            });
+            cleanup(txId);
+        }, PENDING_REVOCATION_TIMEOUT);
+    }
+    /**
+     * Submits a revocation directly without requiring an on-chain transaction.
+     * Used for already-disabled delegations that don't require an on-chain transaction.
+     *
+     * This method:
+     * 1. Adds the permission context to pending revocations state (disables UI button)
+     * 2. Immediately calls submitRevocation to remove from snap storage
+     * 3. On success, removes from pending revocations state (re-enables UI button)
+     * 4. On failure, keeps in pending revocations so UI can show error/retry state
+     *
+     * @param params - The revocation parameters containing the permission context.
+     * @returns A promise that resolves when the revocation is submitted successfully.
+     * @throws {GatorPermissionsProviderError} If the snap request fails.
+     */
+    async submitDirectRevocation(params) {
+        // 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)
+        __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_addPendingRevocationToState).call(this, placeholderTxId, params.permissionContext);
+        // Immediately submit the revocation (will remove from pending on success)
+        await this.submitRevocation(params);
+    }
+    /**
+     * Checks if a permission context is in the pending revocations list.
+     *
+     * @param permissionContext - The permission context to check.
+     * @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);
+    }
+}
+exports.GatorPermissionsController = GatorPermissionsController;
+_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) {
+    this.update((state) => {
+        state.isFetchingGatorPermissions = isFetchingGatorPermissions;
+    });
+}, _GatorPermissionsController_addPendingRevocationToState = function _GatorPermissionsController_addPendingRevocationToState(txId, permissionContext) {
+    this.update((state) => {
+        state.pendingRevocations = [
+            ...state.pendingRevocations,
+            { txId, permissionContext },
+        ];
+    });
+}, _GatorPermissionsController_removePendingRevocationFromStateByTxId = function _GatorPermissionsController_removePendingRevocationFromStateByTxId(txId) {
+    this.update((state) => {
+        state.pendingRevocations = state.pendingRevocations.filter((pendingRevocations) => pendingRevocations.txId !== txId);
+    });
+}, _GatorPermissionsController_removePendingRevocationFromStateByPermissionContext = function _GatorPermissionsController_removePendingRevocationFromStateByPermissionContext(permissionContext) {
+    this.update((state) => {
+        state.pendingRevocations = state.pendingRevocations.filter((pendingRevocations) => pendingRevocations.permissionContext.toLowerCase() !==
+            permissionContext.toLowerCase());
+    });
+}, _GatorPermissionsController_buildPreviousStatusByContext = function _GatorPermissionsController_buildPreviousStatusByContext() {
+    const map = new Map();
+    for (const prev of this.state.grantedPermissions) {
+        map.set(prev.permissionResponse.context.toLowerCase(), prev.status ?? 'Active');
+    }
+    return map;
+}, _GatorPermissionsController_getProviderForChainId = async function _GatorPermissionsController_getProviderForChainId(chainId) {
+    const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+    const { provider } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+    return provider;
+}, _GatorPermissionsController_updateGrantedPermissionsStatus = async function _GatorPermissionsController_updateGrantedPermissionsStatus(grantedPermissions) {
+    return (0, permissionOnChainStatus_js_1.updateGrantedPermissionsStatus)(grantedPermissions, {
+        getProviderForChainId: (chainId) => __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_getProviderForChainId).call(this, chainId),
+    });
+}, _GatorPermissionsController_storedPermissionToPermissionInfo = function _GatorPermissionsController_storedPermissionToPermissionInfo(storedGatorPermission, status) {
+    const { permissionResponse: fullPermissionResponse } = storedGatorPermission;
+    const { dependencies: _dependencies, to: _to, ...permissionResponse } = fullPermissionResponse;
+    return {
+        ...storedGatorPermission,
+        permissionResponse,
+        status,
+    };
+}, _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata = function _GatorPermissionsController_storedPermissionsToPermissionInfoWithMetadata(storedGatorPermissions) {
+    if (!storedGatorPermissions) {
+        return [];
+    }
+    const previousStatusByContext = __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_buildPreviousStatusByContext).call(this);
+    return storedGatorPermissions.map((storedPermission) => {
+        const previousStatus = previousStatusByContext.get(storedPermission.permissionResponse.context.toLowerCase());
+        return __classPrivateFieldGet(this, _GatorPermissionsController_instances, "m", _GatorPermissionsController_storedPermissionToPermissionInfo).call(this, storedPermission, previousStatus ?? 'Active');
+    });
+};
+exports.default = GatorPermissionsController;
+//# sourceMappingURL=GatorPermissionsController.cjs.map