@openfort/react 0.0.33 → 0.1.0

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

@@ -0,0 +1,107 @@
+import type { Hex } from 'viem';
+import type { GrantPermissionsParameters, GrantPermissionsReturnType } from 'viem/experimental';
+import { OpenfortError, type OpenfortHookOptions } from '../../types';
+type GrantPermissionsRequest = {
+    request: GrantPermissionsParameters;
+    sessionKey: Hex;
+};
+type GrantPermissionsResult = {
+    address: `0x${string}`;
+    privateKey: `0x${string}`;
+} & GrantPermissionsReturnType;
+type GrantPermissionsHookResult = {
+    error?: OpenfortError;
+} & Partial<GrantPermissionsResult>;
+type GrantPermissionsHookOptions = OpenfortHookOptions<GrantPermissionsHookResult>;
+/**
+ * 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>
+ * );
+ * ```
+ */
+export declare const useGrantPermissions: (hookOptions?: GrantPermissionsHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+    grantPermissions: ({ request, sessionKey }: GrantPermissionsRequest, options?: GrantPermissionsHookOptions) => Promise<GrantPermissionsHookResult>;
+    data: GrantPermissionsResult | null;
+    reset: () => void;
+};
+export {};

package/build/hooks/usePrevious.d.ts

@@ -1 +1 @@
-export default function usePrevious(value: any, initial?: any): any;
+export default function usePrevious<T>(value: T, initial: T): T;

package/build/hooks/useRouteProps.d.ts

@@ -0,0 +1,35 @@
+import type { RouteOptions } from '../components/Openfort/types';
+export declare const useRouteProps: <T extends RouteOptions["route"]>(currentRoute: T) => Extract<import("../components/Openfort/types").RoutesWithoutOptions, {
+    route: T;
+}> | Extract<{
+    route: "connectors";
+} & {
+    connectType: "link" | "connect" | "linkIfUserConnectIfNoUser";
+}, {
+    route: T;
+}> | Extract<{
+    route: "connectors";
+} & {
+    connectType: "recover";
+    wallet: import("..").UserWallet;
+}, {
+    route: T;
+}> | Extract<{
+    route: "connect";
+} & {
+    connectType: "link" | "connect" | "linkIfUserConnectIfNoUser";
+}, {
+    route: T;
+}> | Extract<{
+    route: "connect";
+} & {
+    connectType: "recover";
+    wallet: import("..").UserWallet;
+}, {
+    route: T;
+}> | Extract<{
+    route: "recoverWallets";
+    wallet: import("..").UserWallet;
+}, {
+    route: T;
+}>;

package/build/index.d.ts

@@ -3,7 +3,7 @@ export { default as Avatar } from './components/Common/Avatar';
 export { default as ChainIcon } from './components/Common/Chain';
 export { OpenfortButton } from './components/ConnectButton';
 export { OpenfortProvider } from './components/Openfort/OpenfortProvider';
-export { UIAuthProvider as AuthProvider } from './components/Openfort/types';
+export { LinkWalletOnSignUpOption, UIAuthProvider as AuthProvider } from './components/Openfort/types';
 export { embeddedWalletId } from './constants/openfort';
 export { default as getDefaultConfig } from './defaultConfig';
 export { default as getDefaultConnectors } from './defaultConnectors';
@@ -15,6 +15,7 @@ export { useSignOut } from './hooks/openfort/auth/useSignOut';
 export { useWalletAuth } from './hooks/openfort/auth/useWalletAuth';
 export { type SignAuthorizationParameters, type SignAuthorizationReturnType, use7702Authorization, } from './hooks/openfort/use7702Authorization';
 export { useConnectWithSiwe } from './hooks/openfort/useConnectWithSiwe';
+export { useGrantPermissions } from './hooks/openfort/useGrantPermissions';
 export { useUI } from './hooks/openfort/useUI';
 export { useUser } from './hooks/openfort/useUser';
 export { UserWallet, useWallets } from './hooks/openfort/useWallets';