@openfort/react 0.3.2 → 1.0.1

package/build/hooks/openfort/auth/useSignOut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignOut.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/hookConsistency.js

@@ -0,0 +1,17 @@
+const onSuccess = ({ hookOptions, options, data, }) => {
+    var _a, _b;
+    (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, data);
+    (_b = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _b === void 0 ? void 0 : _b.call(options, data);
+    return data;
+};
+const onError = ({ hookOptions, options, error, }) => {
+    var _a, _b;
+    (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.onError) === null || _a === void 0 ? void 0 : _a.call(hookOptions, error);
+    (_b = options === null || options === void 0 ? void 0 : options.onError) === null || _b === void 0 ? void 0 : _b.call(options, error);
+    if ((hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.throwOnError) || (options === null || options === void 0 ? void 0 : options.throwOnError))
+        throw error;
+    return { error };
+};
+
+export { onError, onSuccess };
+//# sourceMappingURL=hookConsistency.js.map

package/build/hooks/openfort/hookConsistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookConsistency.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/use7702Authorization.js

@@ -0,0 +1,73 @@
+import { useCallback } from 'react';
+import { parseSignature } from 'viem';
+import { hashAuthorization } from 'viem/utils';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+
+/**
+ * Hook for signing EIP-7702 wallet authorizations
+ *
+ * This hook leverages the embedded Openfort client to sign authorization payloads prepared via viem.
+ * It mirrors viem's `signAuthorization` behaviour while always returning the structured authorization object,
+ * keeping private key management inside the Openfort SDK.
+ *
+ * @returns Helper with a `signAuthorization` function that signs authorizations with the active Openfort wallet
+ *
+ * @example
+ * ```ts
+ * import { prepareAuthorization } from 'viem/actions';
+ * import { use7702Authorization } from '@openfort/openfort-react';
+ *
+ * const { signAuthorization } = use7702Authorization();
+ *
+ * const authorization = await prepareAuthorization(pimlicoClient, {
+ *   account: eoaAccount.address,
+ *   contractAddress: implementationAddress,
+ * });
+ *
+ * const signedAuthorization = await signAuthorization({
+ *   ...authorization,
+ * });
+ * ```
+ */
+function use7702Authorization() {
+    // biome-ignore lint/correctness/useHookAtTopLevel: use7702Authorization is a valid hook name
+    const { client } = useOpenfortCore();
+    // biome-ignore lint/correctness/useHookAtTopLevel: use7702Authorization is a valid hook name
+    const signAuthorization = useCallback(async (parameters, options = {
+        hashMessage: false,
+        arrayifyMessage: false,
+    }) => {
+        if (!client) {
+            throw new OpenfortError('Openfort client is not initialized.', OpenfortReactErrorType.CONFIGURATION_ERROR);
+        }
+        const authorization = parameters;
+        if (!authorization.contractAddress) {
+            throw new OpenfortError('Authorization is missing the contract address to sign.', OpenfortReactErrorType.CONFIGURATION_ERROR);
+        }
+        const hash = hashAuthorization(authorization);
+        try {
+            const signature = await client.embeddedWallet.signMessage(hash, {
+                hashMessage: options.hashMessage,
+                arrayifyMessage: options.arrayifyMessage,
+            });
+            const { r, s, v, yParity } = parseSignature(signature);
+            return {
+                address: authorization.contractAddress,
+                chainId: authorization.chainId,
+                nonce: authorization.nonce,
+                r,
+                s,
+                v,
+                yParity,
+            };
+        }
+        catch (error) {
+            throw new OpenfortError('Failed to sign authorization.', OpenfortReactErrorType.WALLET_ERROR, { error });
+        }
+    }, [client]);
+    return { signAuthorization };
+}
+
+export { use7702Authorization };
+//# sourceMappingURL=use7702Authorization.js.map

package/build/hooks/openfort/use7702Authorization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use7702Authorization.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useGrantPermissions.d.ts

@@ -1,6 +1,7 @@
 import type { Hex } from 'viem';
 import { type GrantPermissionsParameters, type GrantPermissionsReturnType } from 'viem/experimental';
-import { OpenfortError, type OpenfortHookOptions } from '../../types';
+import { OpenfortError } from '../../core/errors';
+import type { OpenfortHookOptions } from '../../types';
 type GrantPermissionsRequest = {
     request: GrantPermissionsParameters;
     sessionKey: Hex;
@@ -13,85 +14,15 @@ type GrantPermissionsHookResult = {
 } & Partial<GrantPermissionsResult>;
 type GrantPermissionsHookOptions = OpenfortHookOptions<GrantPermissionsHookResult>;
 /**
- * Hook for granting permissions to session keys (EIP-7715)
+ * Grants session key permissions for EIP-7702 / account abstraction.
  *
- * This hook manages the creation and authorization of session keys, allowing users to
- * delegate permissions to specific accounts for a limited time. This enables use cases
- * like session-based authentication and gasless transactions within defined scopes.
- * The hook leverages EIP-7715 for permission granting.
- *
- * @param hookOptions - Optional configuration with callback functions
- * @returns Current grant permissions state and actions
+ * @param hookOptions - Optional callbacks and configuration
+ * @returns grantPermissions(request), status, data, error
  *
  * @example
  * ```tsx
- * import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
- * import { useGrantPermissions } from '@openfort/openfort-react';
- *
- * const { grantPermissions, isLoading, isError, error } = useGrantPermissions({
- *   onSuccess: (result) => console.log('Permissions granted:', result),
- *   onError: (error) => console.error('Permission grant failed:', error),
- * });
- *
- * // Grant permissions to a session key
- * const handleGrantPermissions = async () => {
- *   try {
- *     // Generate a new session key
- *     const sessionKey = generatePrivateKey();
- *     const accountSession = privateKeyToAccount(sessionKey).address;
- *
- *     const result = await grantPermissions({
- *       sessionKey,
- *       request: {
- *         signer: {
- *           type: 'account',
- *           data: {
- *             id: accountSession,
- *           },
- *         },
- *         expiry: 60 * 60 * 24, // 24 hours
- *         permissions: [
- *           {
- *             type: 'contract-call',
- *             data: {
- *               address: '0x2522f4fc9af2e1954a3d13f7a5b2683a00a4543a',
- *             },
- *           },
- *         ],
- *       },
- *     });
- *
- *     if (result.address) {
- *       console.log('Session created with address:', result.address);
- *       console.log('Session private key:', result.privateKey);
- *     }
- *   } catch (error) {
- *     console.error('Failed to grant permissions:', error);
- *   }
- * };
- *
- * // Check permission grant state
- * if (isLoading) {
- *   console.log('Granting permissions...');
- * } else if (isError) {
- *   console.error('Permission grant error:', error);
- * }
- *
- * // Example usage in component
- * return (
- *   <div>
- *     <button
- *       onClick={handleGrantPermissions}
- *       disabled={isLoading}
- *     >
- *       {isLoading ? 'Granting Permissions...' : 'Create Session'}
- *     </button>
- *
- *     {isError && (
- *       <p>Error: {error?.message}</p>
- *     )}
- *   </div>
- * );
+ * const { grantPermissions } = useGrantPermissions()
+ * await grantPermissions({ request: { ... } })
  * ```
  */
 export declare const useGrantPermissions: (hookOptions?: GrantPermissionsHookOptions) => {

package/build/hooks/openfort/useGrantPermissions.js

@@ -0,0 +1,221 @@
+import { useState, useCallback } from 'react';
+import { custom, createWalletClient } from 'viem';
+import { erc7715Actions } from 'viem/experimental';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { DEFAULT_TESTNET_CHAIN_ID } from '../../core/ConnectionStrategy.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useEthereumEmbeddedWallet } from '../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useEthereumBridge } from '../../ethereum/OpenfortEthereumBridgeContext.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { logger } from '../../utils/logger.js';
+import { mapStatus } from './auth/status.js';
+import { onSuccess, onError } from './hookConsistency.js';
+
+/**
+ * Hook for granting permissions to session keys (EIP-7715)
+ *
+ * This hook manages the creation and authorization of session keys, allowing users to
+ * delegate permissions to specific accounts for a limited time. This enables use cases
+ * like session-based authentication and gasless transactions within defined scopes.
+ * The hook leverages EIP-7715 for permission granting.
+ *
+ * @param hookOptions - Optional configuration with callback functions
+ * @returns Current grant permissions state and actions
+ *
+ * @example
+ * ```tsx
+ * import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+ * import { useGrantPermissions } from '@openfort/openfort-react';
+ *
+ * const { grantPermissions, isLoading, isError, error } = useGrantPermissions({
+ *   onSuccess: (result) => console.log('Permissions granted:', result),
+ *   onError: (error) => console.error('Permission grant failed:', error),
+ * });
+ *
+ * // Grant permissions to a session key
+ * const handleGrantPermissions = async () => {
+ *   try {
+ *     // Generate a new session key
+ *     const sessionKey = generatePrivateKey();
+ *     const accountSession = privateKeyToAccount(sessionKey).address;
+ *
+ *     const result = await grantPermissions({
+ *       sessionKey,
+ *       request: {
+ *         signer: {
+ *           type: 'account',
+ *           data: {
+ *             id: accountSession,
+ *           },
+ *         },
+ *         expiry: 60 * 60 * 24, // 24 hours
+ *         permissions: [
+ *           {
+ *             type: 'contract-call',
+ *             data: {
+ *               address: '0x2522f4fc9af2e1954a3d13f7a5b2683a00a4543a',
+ *             },
+ *           },
+ *         ],
+ *       },
+ *     });
+ *
+ *     if (result.address) {
+ *       console.log('Session created with address:', result.address);
+ *       console.log('Session private key:', result.privateKey);
+ *     }
+ *   } catch (error) {
+ *     console.error('Failed to grant permissions:', error);
+ *   }
+ * };
+ *
+ * // Check permission grant state
+ * if (isLoading) {
+ *   console.log('Granting permissions...');
+ * } else if (isError) {
+ *   console.error('Permission grant error:', error);
+ * }
+ *
+ * // Example usage in component
+ * return (
+ *   <div>
+ *     <button
+ *       onClick={handleGrantPermissions}
+ *       disabled={isLoading}
+ *     >
+ *       {isLoading ? 'Granting Permissions...' : 'Create Session'}
+ *     </button>
+ *
+ *     {isError && (
+ *       <p>Error: {error?.message}</p>
+ *     )}
+ *   </div>
+ * );
+ * ```
+ */
+async function getEmbeddedWalletClientWithErc7715(provider, chain) {
+    const accounts = (await provider.request({ method: 'eth_accounts' }));
+    if (!(accounts === null || accounts === void 0 ? void 0 : accounts.length))
+        throw new OpenfortError('No accounts available', OpenfortReactErrorType.WALLET_ERROR);
+    const account = accounts[0];
+    const transport = custom(provider);
+    const baseClient = createWalletClient({ account, chain, transport });
+    return baseClient.extend(erc7715Actions());
+}
+/**
+ * Grants session key permissions for EIP-7702 / account abstraction.
+ *
+ * @param hookOptions - Optional callbacks and configuration
+ * @returns grantPermissions(request), status, data, error
+ *
+ * @example
+ * ```tsx
+ * const { grantPermissions } = useGrantPermissions()
+ * await grantPermissions({ request: { ... } })
+ * ```
+ */
+const useGrantPermissions = (hookOptions = {}) => {
+    var _a, _b;
+    const bridge = useEthereumBridge();
+    const { chains } = useOpenfort();
+    const { client } = useOpenfortCore();
+    const ethereum = useEthereumEmbeddedWallet();
+    const chainId = (_b = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.chainId) !== null && _a !== void 0 ? _a : (ethereum.status === 'connected' ? ethereum.chainId : undefined)) !== null && _b !== void 0 ? _b : DEFAULT_TESTNET_CHAIN_ID;
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const [data, setData] = useState(null);
+    const grantPermissions = useCallback(async ({ request }, options = {}) => {
+        try {
+            logger.log('Granting permissions with request:', request);
+            const chain = chains.find((c) => c.id === chainId);
+            if (!chain) {
+                throw new OpenfortError('No chain configured', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            setStatus({
+                status: 'loading',
+            });
+            let account;
+            let grantPermissionsResult;
+            if (bridge === null || bridge === void 0 ? void 0 : bridge.getWalletClient) {
+                // Wagmi connector may still be connecting after auto-recover → READY transition.
+                // Poll briefly before giving up.
+                let rawClient = await bridge.getWalletClient();
+                for (let attempt = 0; !rawClient && attempt < 4; attempt++) {
+                    await new Promise((r) => setTimeout(r, 300));
+                    rawClient = await bridge.getWalletClient();
+                    if (rawClient)
+                        break;
+                }
+                if (!rawClient) {
+                    throw new OpenfortError('Wallet client not available', OpenfortReactErrorType.WALLET_ERROR);
+                }
+                const walletClient = rawClient.extend(erc7715Actions());
+                const [addr] = await walletClient.getAddresses();
+                if (!addr)
+                    throw new OpenfortError('No account on wallet client', OpenfortReactErrorType.WALLET_ERROR);
+                account = addr;
+                grantPermissionsResult = await walletClient.grantPermissions(request);
+            }
+            else {
+                let provider;
+                if (ethereum.status === 'connected') {
+                    provider = await ethereum.activeWallet.getProvider();
+                }
+                else {
+                    provider = (await client.embeddedWallet.getEthereumProvider());
+                    await provider.request({ method: 'eth_requestAccounts' });
+                }
+                const walletClient = await getEmbeddedWalletClientWithErc7715(provider, chain);
+                const [addr] = await walletClient.getAddresses();
+                if (!addr)
+                    throw new OpenfortError('No account on wallet client', OpenfortReactErrorType.WALLET_ERROR);
+                account = addr;
+                grantPermissionsResult = await walletClient.grantPermissions(request);
+            }
+            const data = {
+                address: account,
+                ...grantPermissionsResult,
+            };
+            logger.log('Grant permissions result:', data);
+            setData(data);
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data,
+            });
+        }
+        catch (error) {
+            const isUnsupported = error instanceof Error &&
+                /Method not supported|grantPermissions|wallet_grantPermissions|does not support/i.test(error.message);
+            const message = isUnsupported
+                ? 'Session keys (grantPermissions) are not supported by the embedded wallet provider. Use an external wallet for this flow.'
+                : undefined;
+            const openfortError = new OpenfortError(message !== null && message !== void 0 ? message : 'Failed to grant permissions', OpenfortReactErrorType.WALLET_ERROR, { error });
+            setStatus({
+                status: 'error',
+                error: openfortError,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: openfortError,
+            });
+        }
+    }, [bridge, chains, chainId, client, ethereum, hookOptions]);
+    return {
+        grantPermissions,
+        data,
+        reset: () => {
+            setStatus({ status: 'idle' });
+            setData(null);
+        },
+        ...mapStatus(status),
+    };
+};
+
+export { useGrantPermissions };
+//# sourceMappingURL=useGrantPermissions.js.map

package/build/hooks/openfort/useGrantPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGrantPermissions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useProviders.js

@@ -0,0 +1,75 @@
+import { useEffect, useMemo } from 'react';
+import { UIAuthProvider, socialProviders } from '../../components/Openfort/types.js';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { logger } from '../../utils/logger.js';
+
+function useProviders() {
+    const { user, linkedAccounts } = useOpenfortCore();
+    const { uiConfig: options, thirdPartyAuth, setOpen } = useOpenfort();
+    const allProviders = (options === null || options === void 0 ? void 0 : options.authProviders) || [];
+    const providers = allProviders.filter((p) => p !== UIAuthProvider.GUEST) || [];
+    const linkedProviders = user ? providers.filter((p) => linkedAccounts === null || linkedAccounts === void 0 ? void 0 : linkedAccounts.find((a) => a.provider === p)) : [];
+    const availableProviders = user
+        ? providers.filter((provider) => {
+            if (provider === UIAuthProvider.WALLET)
+                return true; // Wallet is always available
+            if (user.email && (provider === UIAuthProvider.EMAIL_PASSWORD || provider === UIAuthProvider.EMAIL_OTP)) {
+                return false; // If user has email, don't show email password or otp
+            }
+            if (provider === UIAuthProvider.EMAIL_PASSWORD)
+                return false; // Disable email password linking for now
+            if (user.phoneNumber && provider === UIAuthProvider.PHONE) {
+                return false; // If user has phone number, don't show phone otp
+            }
+            return !(linkedAccounts === null || linkedAccounts === void 0 ? void 0 : linkedAccounts.find((a) => a.provider === provider));
+        })
+        : providers;
+    useEffect(() => {
+        if (thirdPartyAuth) {
+            setOpen(false);
+            logger.error(new OpenfortError('When using external third party auth providers, openfort Auth providers are not available. Either remove the `thirdPartyAuth` or authenticate your users using Auth hooks.', OpenfortReactErrorType.CONFIGURATION_ERROR));
+        }
+    }, [thirdPartyAuth, setOpen]);
+    const maxProviders = (options === null || options === void 0 ? void 0 : options.authProvidersLength) || 4;
+    const { mainProviders, hasExcessProviders, remainingSocialProviders } = useMemo(() => {
+        const activeProviders = user ? availableProviders : allProviders;
+        if (activeProviders.length <= maxProviders) {
+            return { mainProviders: activeProviders, hasExcessProviders: false, remainingSocialProviders: [] };
+        }
+        // Separate social and non-social providers
+        const nonSocial = activeProviders.filter((p, _, array) => {
+            if (p === UIAuthProvider.EMAIL_OTP && array.includes(UIAuthProvider.EMAIL_PASSWORD)) {
+                // If both email otp and email password are present, treat email otp as social to avoid showing both
+                return false;
+            }
+            return !socialProviders.includes(p);
+        });
+        const social = activeProviders.filter((p) => socialProviders.includes(p));
+        // Allow as many non-socials as possible, then fill the rest with socials
+        const remainingSlots = maxProviders - nonSocial.length;
+        const remainingSocialProviders = social.slice(Math.max(0, remainingSlots - 1));
+        return {
+            mainProviders: [...nonSocial, ...social.slice(0, Math.max(0, remainingSlots - 1))].sort((a, b) => {
+                // sort them in the original order
+                const indexA = activeProviders.indexOf(a);
+                const indexB = activeProviders.indexOf(b);
+                return indexA - indexB;
+            }),
+            hasExcessProviders: social.length > remainingSlots - 1,
+            remainingSocialProviders,
+        };
+    }, [user, availableProviders, allProviders, maxProviders]);
+    return {
+        availableProviders,
+        linkedProviders,
+        allProviders,
+        mainProviders,
+        hasExcessProviders,
+        remainingSocialProviders,
+    };
+}
+
+export { useProviders };
+//# sourceMappingURL=useProviders.js.map

package/build/hooks/openfort/useProviders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProviders.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useRevokePermissions.d.ts

@@ -1,6 +1,7 @@
 import type { SessionResponse } from '@openfort/openfort-js';
 import type { Hex } from 'viem';
-import { OpenfortError, type OpenfortHookOptions } from '../../types';
+import { OpenfortError } from '../../core/errors';
+import type { OpenfortHookOptions } from '../../types';
 type RevokePermissionsRequest = {
     sessionKey: Hex;
 };

package/build/hooks/openfort/useRevokePermissions.js

@@ -0,0 +1,126 @@
+import { useState, useCallback } from 'react';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { DEFAULT_TESTNET_CHAIN_ID } from '../../core/ConnectionStrategy.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { getEmbeddedWalletClient } from '../../ethereum/hooks/getEmbeddedWalletClient.js';
+import { useEthereumEmbeddedWallet } from '../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { logger } from '../../utils/logger.js';
+import { mapStatus } from './auth/status.js';
+import { onSuccess, onError } from './hookConsistency.js';
+
+/**
+ * Hook for revoking permissions to session keys (EIP-7715)
+ *
+ * This hook manages the creation and authorization of session keys, allowing users to
+ * delegate permissions to specific accounts for a limited time. This enables use cases
+ * like session-based authentication and gasless transactions within defined scopes.
+ * The hook leverages EIP-7715 for permission revocation.
+ *
+ * @param hookOptions - Optional configuration with callback functions
+ * @returns Current revoke permissions state and actions
+ *
+ * @example
+ * ```tsx
+ * import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+ * import { useRevokePermissions } from '@openfort/openfort-react';
+ *
+ * const { revokePermissions, isLoading, isError, error } = useRevokePermissions({
+ *   onSuccess: (result) => console.log('Permissions revoked:', result),
+ *   onError: (error) => console.error('Permission revoke failed:', error),
+ * });
+ *
+ * // Revoke Permissions to a session key
+ * const handleRevokePermissions = async () => {
+ *   try {
+ *     const sessionKey = '0x...'; // The session key to revoke permissions for
+ *
+ *     const result = await revokePermissions({
+ *       sessionKey,
+ *     });
+ *
+ *     console.log('Revoke result:', result);
+ *   } catch (error) {
+ *     console.error('Error revoking permissions:', error);
+ *   }
+ * };
+ * ```
+ */
+const useRevokePermissions = (hookOptions = {}) => {
+    var _a;
+    const { chains } = useOpenfort();
+    const { client } = useOpenfortCore();
+    const ethereum = useEthereumEmbeddedWallet();
+    const chainId = (_a = ethereum.chainId) !== null && _a !== void 0 ? _a : DEFAULT_TESTNET_CHAIN_ID;
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const [data, setData] = useState(null);
+    const revokePermissions = useCallback(async ({ sessionKey }, options = {}) => {
+        try {
+            const chain = chains.find((c) => c.id === chainId);
+            if (!chain) {
+                throw new OpenfortError('No chain configured', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            logger.log('Revoking permissions for session key:', sessionKey);
+            setStatus({
+                status: 'loading',
+            });
+            const revokeParams = [
+                {
+                    permissionContext: sessionKey,
+                },
+            ];
+            let provider;
+            if (ethereum.status === 'connected') {
+                provider = await ethereum.activeWallet.getProvider();
+            }
+            else {
+                provider = (await client.embeddedWallet.getEthereumProvider());
+                await provider.request({ method: 'eth_requestAccounts' });
+            }
+            const walletClient = await getEmbeddedWalletClient(provider, chain);
+            const revokePermissionsResult = await walletClient.request({
+                method: 'wallet_revokePermissions',
+                params: revokeParams,
+            });
+            logger.log('Revoke permissions result:', revokePermissionsResult);
+            const data = revokePermissionsResult;
+            setData(data);
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data,
+            });
+        }
+        catch (error) {
+            const openfortError = new OpenfortError('Failed to revoke permissions', OpenfortReactErrorType.WALLET_ERROR, {
+                error,
+            });
+            setStatus({
+                status: 'error',
+                error: openfortError,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: openfortError,
+            });
+        }
+    }, [chains, chainId, client, ethereum, hookOptions]);
+    return {
+        revokePermissions,
+        data,
+        reset: () => {
+            setStatus({ status: 'idle' });
+            setData(null);
+        },
+        ...mapStatus(status),
+    };
+};
+
+export { useRevokePermissions };
+//# sourceMappingURL=useRevokePermissions.js.map

package/build/hooks/openfort/useRevokePermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRevokePermissions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}