@openfort/react 0.0.1 → 0.0.3

package/README.md

@@ -10,22 +10,18 @@
       Documentation
     </a>
     <span> | </span>
-    <a href="https://www.openfort.io/docs/reference/api/authentication">
-      API Docs
-    </a>
-    <span> | </span>
     <a href="https://x.com/openfort_hq">
       X
     </a>
-        <span> | </span>
-    <a href="https://create-next-app.openfort.xyz/">
+   <span> | </span>
+    <a href="https://playground.openfort.io/">
       Demo
     </a>
   </h4>
 </div>
 
 
-# Openfort Kit
+# Openfort React SDK
 
 [![Downloads](https://img.shields.io/npm/dm/@openfort/react.svg)](https://www.npmjs.com/package/@openfort/react)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
@@ -33,18 +29,14 @@
 [![Version](https://img.shields.io/npm/v/@openfort/react.svg)](https://www.npmjs.org/package/@openfort/react)
 
 
-The easiest way to integrate Openfort to your project, with built-in authentication and seamless wallet connectivity.
-
-It offers a simple, customizable UI. Supports authentication providers like Google, X, or Facebook out of the box. Access your address through Openfort’s [invisible wallet](https://www.openfort.io/docs/products/embedded-wallet/javascript) or connect their own wallet provider effortlessly.
-
-Docs: https://www.openfort.io/docs/products/embedded-wallet/react/kit
+The easiest way to use embedded wallets, with built-in authentication and payments capabilities.
 
 ## Features
 
 - 💡 TypeScript Ready — Get types straight out of the box.
-- 🌱 Ecosystem Standards — Uses top libraries such as [wagmi](https://github.com/wagmi-dev/wagmi).
-- 🖥️ Simple UX — Give users a simple, attractive experience.
-- 🎨 Beautiful Themes — Predesigned themes or full customization.
+- 🌱 Ecosystem Friendly — Uses top libraries such as [wagmi](https://github.com/wagmi-dev/wagmi) for hooks.
+- 🎨 Simple UI — Use prebuilt elements for authenticaiton and wallet connection.
+- 🖥️ React Hooks - To interact directly with embedded wallet capabilities.
 
 and much more...
 
@@ -57,24 +49,24 @@ Get started with `create` Openfortkit + [wagmi](https://wagmi.sh/) + [viem](http
 #### npm
 
 ```sh
-npx create openfortkit
+npx create openfort
 ```
 
 #### yarn
 
 ```sh
-yarn create openfortkit
+yarn create openfort
 ```
 
 #### pnpm
 
 ```sh
-pnpm create openfortkit
+pnpm create openfort
 ```
 
-### Import `OpenfortKit` to your project
+### Import `Openfort` to your project
 
-Add OpenfortKit to your already existing project.
+Add Openfort to your already existing project.
 
 #### npm
 
@@ -94,25 +86,21 @@ yarn add @openfort/react @tanstack/react-query wagmi viem
 pnpm add @openfort/react @tanstack/react-query wagmi viem
 ```
 
-## Documentation
-
-You can find the full OpenfortKit documentation in the Family docs [here]().
-
 ## Examples
 
-There are various runnable examples included in this repository in the [examples folder](https://github.com/openfort-xyz/openfort-kit/tree/main/examples):
+There are various runnable examples included in this repository in the [examples folder](https://github.com/openfort-xyz/openfort-react/tree/main/examples):
 
-- [Create React App Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/cra)
-- [Next.js Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/nextjs)
-- [Vite Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/vite)
+- [Create React App Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/cra)
+- [Next.js Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/nextjs)
+- [Vite Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/vite)
 
 ### Running Examples Locally
 
-Clone the FortKit project and install the necessary dependencies:
+Clone the project and install the necessary dependencies:
 
 ```sh
 $ git clone git@github.com:openfort-xyz/openfort-kit.git
-$ cd openfort-kit
+$ cd openfort
 $ yarn install
 ```
 

package/build/components/{OpenfortKit → Openfort}/OpenfortKit.d.ts

@@ -1,28 +1,28 @@
 import React from 'react';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import { ContextValue } from './context';
-import { ConnectKitOptions, OpenfortWalletConfig } from './types';
-type OpenfortKitProviderProps = {
+import { ConnectUIOptions, OpenfortWalletConfig } from './types';
+type OpenfortProviderProps = {
     children?: React.ReactNode;
     debugMode?: boolean;
     publishableKey: string;
-    uiConfig?: ConnectKitOptions;
+    uiConfig?: ConnectUIOptions;
     walletConfig?: OpenfortWalletConfig;
 } & useConnectCallbackProps;
 /**
- * OpenfortKitProvider component provides context and configuration for OpenfortKit.
+ * OpenfortProvider component provides context and configuration for OpenfortKit.
  * It must be used within a WagmiProvider.
  *
  * @param {React.ReactNode} children - The child components to be wrapped by the provider.
  * @param {string} [theme='auto'] - The theme to be used, default is 'auto'.
  * @param {string} [mode='auto'] - The mode to be used, default is 'auto'.
  * @param {CustomTheme} [customTheme] - Custom theme configuration.
- * @param {ConnectKitOptions} [options] - Additional configuration options.
+ * @param {ConnectUIOptions} [options] - Additional configuration options.
  * @param {Function} [onConnect] - Callback function to be called on connect.
  * @param {Function} [onDisconnect] - Callback function to be called on disconnect.
  * @param {boolean} [debugMode=false] - Enable or disable debug mode, default is false.
  * @param {OpenfortOptions} [openfortOptions] - Options for Openfort integration.
  * @throws Will throw an error if used outside of a WagmiProvider or if nested usages are detected.
  */
-export declare const OpenfortKitProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, }: OpenfortKitProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
+export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
 export {};

package/build/components/{OpenfortKit → Openfort}/context.d.ts

@@ -3,7 +3,7 @@ import { CustomTheme, Languages, Mode, Theme } from '../../types';
 import { OAuthProvider } from '@openfort/openfort-js';
 import { ValueOf } from 'viem/_types/types/utils';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
-import { ConnectKitOptionsExtended, OpenfortWalletConfig, routes } from './types';
+import { OpenfortUIOptionsExtended, OpenfortWalletConfig, routes } from './types';
 type Connector = {
     id: string;
     type?: "wallet";
@@ -31,7 +31,7 @@ export type ContextValue = {
     displayError: (message: string | React.ReactNode | null, code?: any) => void;
     resize: number;
     triggerResize: () => void;
-    uiConfig?: ConnectKitOptionsExtended;
+    uiConfig?: OpenfortUIOptionsExtended;
     walletConfig?: OpenfortWalletConfig;
 } & useConnectCallbackProps;
 export declare const OpenfortKitContext: React.Context<ContextValue | null>;

package/build/components/{OpenfortKit → Openfort}/types.d.ts

@@ -1,7 +1,7 @@
 import React, { ReactNode } from 'react';
 import { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from '../../types';
 import { RecoveryMethod } from '@openfort/openfort-js';
-import { OpenfortProviderProps } from '../../openfort/OpenfortProvider';
+import { CoreOpenfortProviderProps } from '../../openfort/OpenfortProvider';
 export declare const routes: {
     readonly PROVIDERS: "providers";
     readonly SOCIAL_PROVIDERS: "socialProviders";
@@ -84,9 +84,9 @@ export type OpenfortOptions = {
     termsOfServiceUrl?: string;
     privacyPolicyUrl?: string;
     logo?: React.ReactNode;
-    openfortUrlOverrides?: OpenfortProviderProps['overrides'];
+    openfortUrlOverrides?: CoreOpenfortProviderProps['overrides'];
 };
-export type ConnectKitOptions = {
+export type ConnectUIOptions = {
     theme?: Theme;
     mode?: Mode;
     customTheme?: CustomTheme;
@@ -107,7 +107,7 @@ export type ConnectKitOptions = {
     enforceSupportedChains?: boolean;
     overlayBlur?: number;
 } & OpenfortOptions;
-export type ConnectKitOptionsExtended = {
+export type OpenfortUIOptionsExtended = {
     theme: Theme;
     mode: Mode;
     customTheme?: CustomTheme;

package/build/components/Pages/Providers/index.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AuthProvider } from "../../OpenfortKit/types";
+import { AuthProvider } from "../../Openfort/types";
 export declare const ProviderButtonSwitch: React.FC<{
     provider: AuthProvider;
 }>;

package/build/hooks/openfort/auth/status.d.ts

@@ -1,14 +1,14 @@
-import { OpenfortKitError } from "../../../types";
+import { OpenfortError } from "../../../types";
 export type BaseFlowState = {
     status: "idle" | 'awaiting-input' | 'loading' | 'success';
     error?: never;
 } | {
     status: 'error';
-    error: OpenfortKitError | null;
+    error: OpenfortError | null;
 };
 export declare const mapStatus: (status: BaseFlowState) => {
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
 };

package/build/hooks/openfort/auth/useAuthCallback.d.ts

@@ -1,39 +1,24 @@
-import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
-import { AuthProvider } from "../../../components/OpenfortKit/types";
-import { UserWallet } from "../useWallets";
-import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
-type CallbackResult = StoreCredentialsResult | EmailVerificationResult;
-type EmailVerificationResult = {
-    type: "verifyEmail";
-    email?: string;
-    error?: OpenfortKitError;
-};
-type StoreCredentialsResult = {
+import { OpenfortHookOptions, OpenfortError } from "../../../types";
+import { AuthProvider } from "../../../components/Openfort/types";
+import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
+import { EmailVerificationResult } from "./useEmailAuth";
+import { StoreCredentialsResult } from "./useOAuth";
+type CallbackResult = (StoreCredentialsResult & {
     type: "storeCredentials";
-    user?: OpenfortUser;
-    wallet?: UserWallet;
-    error?: OpenfortKitError;
-};
-type VerifyEmailOptions = {
-    email: string;
-    state: string;
-} & OpenfortHookOptions<EmailVerificationResult>;
-type StoreCredentialsOptions = {
-    player: string;
-    accessToken: string;
-    refreshToken: string;
-} & OpenfortHookOptions<StoreCredentialsResult>;
+}) | (EmailVerificationResult & {
+    type: "verifyEmail";
+});
 type UseAuthCallbackOptions = {
-    automaticallyHandleCallback?: boolean;
-} & OpenfortHookOptions<CallbackResult>;
-export declare const useAuthCallback: ({ automaticallyHandleCallback, ...hookOptions }?: UseAuthCallbackOptions) => {
+    enabled?: boolean;
+} & OpenfortHookOptions<CallbackResult> & CreateWalletPostAuthOptions;
+export declare const useAuthCallback: ({ enabled, ...hookOptions }?: UseAuthCallbackOptions) => {
+    email: string | null;
+    provider: AuthProvider | null;
+    verifyEmail: ({ email, state, ...options }: import("./useEmailAuth").VerifyEmailOptions) => Promise<EmailVerificationResult>;
+    storeCredentials: ({ player, accessToken, refreshToken, ...options }: import("./useOAuth").StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
-    email: string | null;
-    provider: AuthProvider | null;
-    verifyEmail: ({ email, state, ...options }: VerifyEmailOptions) => Promise<EmailVerificationResult>;
-    storeCredentials: ({ player, accessToken, refreshToken, ...options }: StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
+    error: OpenfortError | null | undefined;
 };
 export {};

package/build/hooks/openfort/auth/useCreateWalletPostAuth.d.ts

@@ -1,6 +1,17 @@
+export type CreateWalletPostAuthOptions = {
+    /**
+     * @default true
+     * It will log out the user if there is an error while trying to create a wallet (automatic recovery).
+     */
+    logoutOnError?: boolean;
+    /**
+     *
+     */
+    automaticRecovery?: boolean;
+};
 export declare const useCreateWalletPostAuth: () => {
-    tryUseWallet: () => Promise<{
-        error?: string;
+    tryUseWallet: ({ logoutOnError: signOutOnError, automaticRecovery }: CreateWalletPostAuthOptions) => Promise<{
+        error?: import("../../..").OpenfortError;
         wallet?: import("../useWallets").UserWallet;
     }>;
 };

package/build/hooks/openfort/auth/useEmailAuth.d.ts

@@ -1,8 +1,9 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
-import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { OpenfortHookOptions, OpenfortError } from "../../../types";
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
 import { UserWallet } from '../useWallets';
 export type EmailAuthResult = {
-    error?: OpenfortKitError;
+    error?: OpenfortError;
     user?: OpenfortUser;
     wallet?: UserWallet;
     requiresEmailVerification?: boolean;
@@ -11,13 +12,13 @@ export type SignInEmailOptions = {
     email: string;
     password: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
 export type SignUpEmailOptions = {
     email: string;
     password: string;
     name?: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
 export type RequestResetPasswordOptions = {
     email: string;
     emailVerificationRedirectTo?: string;
@@ -32,18 +33,27 @@ export type LinkEmailOptions = {
     password: string;
     emailVerificationRedirectTo?: string;
 } & OpenfortHookOptions<EmailAuthResult>;
+export type VerifyEmailOptions = {
+    email: string;
+    state: string;
+} & OpenfortHookOptions<EmailVerificationResult>;
+export type EmailVerificationResult = {
+    email?: string;
+    error?: OpenfortError;
+};
 export type UseEmailHookOptions = {
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult> & CreateWalletPostAuthOptions;
 export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     requiresEmailVerification: boolean;
     isAwaitingInput: boolean;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
     signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
     signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
+    verifyEmail: ({ email, state, ...options }: VerifyEmailOptions) => Promise<EmailVerificationResult>;
     linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
     requestResetPassword: (options: RequestResetPasswordOptions) => Promise<EmailAuthResult>;
     resetPassword: (options: ResetPasswordOptions) => Promise<EmailAuthResult>;

package/build/hooks/openfort/auth/useGuestAuth.d.ts

@@ -1,16 +1,17 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
-import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { OpenfortHookOptions, OpenfortError } from "../../../types";
+import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
 import { UserWallet } from "../useWallets";
 export type GuestHookResult = {
-    error?: OpenfortKitError;
+    error?: OpenfortError;
     user?: OpenfortUser;
     wallet?: UserWallet;
 };
-export type GuestHookOptions = OpenfortHookOptions<OpenfortUser>;
+export type GuestHookOptions = OpenfortHookOptions<OpenfortUser> & CreateWalletPostAuthOptions;
 export declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
     signUpGuest: (options?: GuestHookOptions) => Promise<GuestHookResult>;
 };

package/build/hooks/openfort/auth/useOAuth.d.ts

@@ -1,20 +1,34 @@
-import { AuthProvider } from '../../../components/OpenfortKit/types';
-import { OpenfortHookOptions, OpenfortKitError } from '../../../types';
+import { AuthProvider } from '../../../components/Openfort/types';
+import { OpenfortHookOptions, OpenfortError } from '../../../types';
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+import { UserWallet } from "../useWallets";
+import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 export type InitializeOAuthOptions = {
     provider: AuthProvider;
     redirectTo?: string;
 } & OpenfortHookOptions;
-export type AuthHookOptions = {
-    redirectTo?: string;
-} & OpenfortHookOptions;
 export type InitOAuthReturnType = {
-    error?: OpenfortKitError;
+    error?: OpenfortError;
 };
+export type StoreCredentialsResult = {
+    user?: OpenfortUser;
+    wallet?: UserWallet;
+    error?: OpenfortError;
+};
+export type StoreCredentialsOptions = {
+    player: string;
+    accessToken: string;
+    refreshToken: string;
+} & OpenfortHookOptions<StoreCredentialsResult> & CreateWalletPostAuthOptions;
+export type AuthHookOptions = {
+    redirectTo?: string;
+} & OpenfortHookOptions<StoreCredentialsResult> & CreateWalletPostAuthOptions;
 export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
     initOAuth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
     linkOauth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+    storeCredentials: ({ player, accessToken, refreshToken, ...options }: StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
 };

package/build/hooks/openfort/auth/useSignOut.d.ts

@@ -1,8 +1,8 @@
-import { OpenfortHookOptions, OpenfortKitError } from '../../../types';
+import { OpenfortHookOptions, OpenfortError } from '../../../types';
 export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
     signOut: (options?: OpenfortHookOptions) => Promise<{} | undefined>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
 };

package/build/hooks/openfort/auth/useWalletAuth.d.ts

@@ -1,5 +1,5 @@
 import { Connector } from "wagmi";
-import { OpenfortHookOptions, OpenfortKitError } from "../../../types";
+import { OpenfortHookOptions, OpenfortError } from "../../../types";
 type ConnectWalletOptions = {
     connector: Connector | string;
 };
@@ -7,13 +7,13 @@ export declare const useWalletAuth: (hookOptions?: OpenfortHookOptions) => {
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
+    error: OpenfortError | null | undefined;
     walletConnectingTo: string | null;
     connectWallet: (options: ConnectWalletOptions) => Promise<{
-        error: OpenfortKitError;
+        error: OpenfortError;
     } | undefined>;
     linkWallet: (options: ConnectWalletOptions) => Promise<{
-        error: OpenfortKitError;
+        error: OpenfortError;
     } | undefined>;
     availableWallets: import("../../../wallets/useWallets").WalletProps[];
 };

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

@@ -1,4 +1,4 @@
-import { OpenfortHookOptions, OpenfortKitError } from "../../types";
+import { OpenfortHookOptions, OpenfortError } from "../../types";
 export declare const onSuccess: <T>({ hookOptions, options, data, }: {
     hookOptions?: OpenfortHookOptions<T>;
     options?: OpenfortHookOptions<T>;
@@ -7,7 +7,7 @@ export declare const onSuccess: <T>({ hookOptions, options, data, }: {
 export declare const onError: <T>({ hookOptions, options, error, }: {
     hookOptions?: OpenfortHookOptions<T>;
     options?: OpenfortHookOptions<T>;
-    error: OpenfortKitError;
+    error: OpenfortError;
 }) => {
-    error: OpenfortKitError;
+    error: OpenfortError;
 };

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

@@ -1,4 +1,4 @@
-import { AuthProvider } from "../../components/OpenfortKit/types";
+import { AuthProvider } from "../../components/Openfort/types";
 export declare function useProviders(): {
     availableProviders: AuthProvider[];
     linkedProviders: AuthProvider[];

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

@@ -1,16 +1,13 @@
 export declare enum OpenfortKitStatus {
-    LOADING = 0,
-    CONNECTED = 1,
-    DISCONNECTED = 2,
-    NEEDS_RECOVERY = 3,
-    CONNECTED_WITHOUT_USER = 4
+    DISCONNECTED = 0,
+    NEEDS_RECOVERY = 1,
+    LOADING = 2,
+    CONNECTED = 3
 }
 export declare function useStatus(): {
-    status: OpenfortKitStatus;
     isLoading: boolean;
-    hasUser: boolean;
     isConnected: boolean;
     isDisconnected: boolean;
-    isConnectedWithoutUser: boolean;
-    needsRecovery: boolean;
+    isConnecting: boolean;
+    isAuthenticated: boolean;
 };

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

@@ -1,5 +1,6 @@
 export declare function useUser(): {
     user: import("@openfort/openfort-js").AuthPlayerResponse | null;
+    isAuthenticated: boolean;
     getAccessToken: () => Promise<string | null>;
     validateAndRefreshToken: () => Promise<void>;
 };

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

@@ -0,0 +1 @@
+export declare function useWallet(): import("./useWallets").UserWallet | undefined;

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

@@ -1,7 +1,7 @@
+import { Hex } from "viem";
 import { Connector } from "wagmi";
 import { embeddedWalletId } from "../../constants/openfort";
-import { Hex } from "viem";
-import { OpenfortKitError } from "../../types";
+import { OpenfortError, OpenfortHookOptions } from "../../types";
 export type UserWallet = {
     address?: `0x${string}`;
     connectorType?: string;
@@ -9,9 +9,14 @@ export type UserWallet = {
     connector?: Connector;
     id: string;
     isAvailable: boolean;
-    isActive: boolean;
+    isActive?: boolean;
+    isConnecting?: boolean;
 };
-type SetActiveWalletOptions = {
+type SetActiveWalletResult = {
+    error?: OpenfortError;
+    wallet?: UserWallet;
+};
+type SetActiveWalletOptions = ({
     showUI?: boolean;
     address?: Hex | undefined;
 } & ({
@@ -19,19 +24,36 @@ type SetActiveWalletOptions = {
 } | {
     connector: typeof embeddedWalletId;
     password?: string;
-});
-export declare function useWallets(): {
+})) & OpenfortHookOptions<SetActiveWalletResult>;
+type CreateWalletResult = SetActiveWalletResult;
+type CreateWalletOptions = {
+    password?: string;
+} & OpenfortHookOptions<CreateWalletResult>;
+type WalletOptions = OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
+export declare function useWallets(hookOptions?: WalletOptions): {
     exportPrivateKey: () => Promise<string>;
-    isLoading: boolean;
+    error: OpenfortError | null | undefined;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortKitError | null | undefined;
-    wallets: UserWallet[];
+    isCreating: boolean;
+    isConnecting: boolean;
+    wallets: {
+        isConnecting: boolean;
+        isActive: boolean;
+        address?: `0x${string}`;
+        connectorType?: string;
+        walletClientType?: string;
+        connector?: Connector;
+        id: string;
+        isAvailable: boolean;
+    }[];
     availableWallets: import("../../wallets/useWallets").WalletProps[];
     activeWallet: UserWallet | undefined;
-    setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<{
-        error?: string;
-        wallet?: UserWallet;
+    setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<SetActiveWalletResult>;
+    createWallet: ({ password, ...options }?: CreateWalletOptions) => Promise<{
+        error: OpenfortError;
+    } | {
+        wallet: UserWallet;
     }>;
 };
 export {};

package/build/index.d.ts

@@ -3,9 +3,9 @@ export * from './types';
 export { default as getDefaultConfig } from './defaultConfig';
 export { default as getDefaultConnectors } from './defaultConnectors';
 export { wallets } from './wallets';
-export { AuthProvider, } from './components/OpenfortKit/types';
-export { OpenfortKitContext, } from './components/OpenfortKit/context';
-export { OpenfortKitProvider, } from './components/OpenfortKit/OpenfortKit';
+export { AuthProvider, } from './components/Openfort/types';
+export { OpenfortKitContext, } from './components/Openfort/context';
+export { OpenfortProvider, } from './components/Openfort/OpenfortKit';
 export { OpenfortKitButton } from './components/ConnectButton';
 export { default as Avatar } from './components/Common/Avatar';
 export { default as ChainIcon } from './components/Common/Chain';
@@ -15,8 +15,9 @@ export { useStatus, OpenfortKitStatus } from './hooks/openfort/useStatus';
 export { useUser } from './hooks/openfort/useUser';
 export { useUI } from "./hooks/openfort/useUI";
 export { useWallets, UserWallet } from "./hooks/openfort/useWallets";
+export { useWallet } from "./hooks/openfort/useWallet";
 export { RecoveryMethod, AuthPlayerResponse } from "@openfort/openfort-js";
-export { useOpenfort } from './openfort/useOpenfort';
+export { useOpenfortCore as useOpenfort } from './openfort/useOpenfort';
 export { useConnectWithSiwe } from './hooks/openfort/useConnectWithSiwe';
 export { embeddedWalletId } from './constants/openfort';
 export { useEmailAuth } from './hooks/openfort/auth/useEmailAuth';