@chipi-stack/chipi-react 11.22.0 → 12.1.0

package/dist/hooks.d.ts

@@ -1,6 +1,6 @@
-import { CreateWalletParams, CreateWalletResponse, GetWalletParams, GetWalletResponse, TransferHookInput, ApproveHookInput, GetTransactionListQuery, PaginatedResponse, Transaction, CreateSkuTransactionParams, SkuTransaction, GetSkuListQuery, Sku, StakeVesuUsdcHookInputParams, WithdrawVesuUsdcHookInputParams, CallAnyContractParams, RecordSendTransactionParams, GetTokenBalanceParams, GetTokenBalanceResponse, GetUserParams, User, WalletData, CreateUserParams } from '@chipi-stack/types';
+import { CreateWalletParams, CreateWalletResponse, GetWalletParams, GetWalletResponse, ChainToken, GetTokenBalanceResponse, WalletType, WalletData, SessionKeyData, SessionDataResponse, CreateSessionKeyParams, SessionConfig, Call, TransferHookInput, ApproveHookInput, GetTransactionListQuery, PaginatedResponse, Transaction, CreateSkuTransactionParams, SkuTransaction, GetSkuListQuery, Sku, StakeVesuUsdcHookInputParams, WithdrawVesuUsdcHookInputParams, CallAnyContractParams, RecordSendTransactionParams, GetTokenBalanceParams, GetUserParams, User, CreateUserParams, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, ExecuteWithSessionParams } from '@chipi-stack/types';
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseQueryOptions } from '@tanstack/react-query';
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
 
 type CreateWalletInput = {
     params: CreateWalletParams;
@@ -23,17 +23,11 @@ declare function useCreateWallet(): {
 type GetWalletInput = {
     params?: GetWalletParams;
     getBearerToken?: () => Promise<string | null | undefined>;
-    queryOptions?: Omit<UseQueryOptions<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>, "queryKey" | "queryFn">;
+    queryOptions?: Omit<UseQueryOptions<GetWalletResponse | null, Error>, "queryKey" | "queryFn">;
 };
 declare function useGetWallet(input?: GetWalletInput): {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
-    data: (GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
     error: Error;
     isError: true;
     isPending: false;
@@ -56,20 +50,12 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 } | {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
-    data: (GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
     error: null;
     isError: false;
     isPending: false;
@@ -92,17 +78,11 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 } | {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
     data: undefined;
     error: Error;
     isError: true;
@@ -126,17 +106,11 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 } | {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
     data: undefined;
     error: null;
     isError: false;
@@ -160,17 +134,11 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 } | {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
     data: undefined;
     error: null;
     isError: false;
@@ -194,20 +162,12 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 } | {
-    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
-    data: (GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null;
+    fetchWallet: (newInput: GetWalletInput) => Promise<GetWalletResponse | null>;
+    data: GetWalletResponse | null;
     isError: false;
     error: null;
     isPending: false;
@@ -230,15 +190,260 @@ declare function useGetWallet(input?: GetWalletInput): {
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null, Error>>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetWalletResponse | null, Error>>;
     fetchStatus: _tanstack_react_query.FetchStatus;
-    promise: Promise<(GetWalletResponse & {
-        normalizedPublicKey: string;
-    }) | null>;
+    promise: Promise<GetWalletResponse | null>;
 };
 
+/**
+ * Configuration for useChipiWallet hook
+ */
+interface UseChipiWalletConfig {
+    /** External user ID (e.g., from Clerk, Firebase, etc.) */
+    externalUserId: string | null | undefined;
+    /** Function to get the bearer token for API calls */
+    getBearerToken: () => Promise<string | null | undefined>;
+    /** Default token for balance display (defaults to USDC) */
+    defaultToken?: ChainToken;
+    /** Whether to automatically fetch wallet on mount */
+    enabled?: boolean;
+}
+/**
+ * Extended wallet response with additional computed properties
+ */
+interface ChipiWalletData extends GetWalletResponse {
+    /** Whether this wallet supports session keys */
+    supportsSessionKeys: boolean;
+    /** Formatted short address for display */
+    shortAddress: string;
+}
+/**
+ * Return type for useChipiWallet hook
+ */
+interface UseChipiWalletReturn {
+    /** The user's wallet data, null if not found, undefined if loading */
+    wallet: ChipiWalletData | null | undefined;
+    /** Whether the user has a wallet */
+    hasWallet: boolean;
+    /** Whether the wallet is currently being fetched */
+    isLoadingWallet: boolean;
+    /** Error from fetching wallet */
+    walletError: Error | null;
+    /** The wallet's balance for the default token */
+    balance: GetTokenBalanceResponse | undefined;
+    /** Formatted balance string (e.g., "100.50") */
+    formattedBalance: string;
+    /** Whether balance is loading */
+    isLoadingBalance: boolean;
+    /** Create a new wallet */
+    createWallet: (params: {
+        encryptKey: string;
+        walletType?: WalletType;
+    }) => Promise<CreateWalletResponse>;
+    /** Whether wallet creation is in progress */
+    isCreating: boolean;
+    /** Data from the last wallet creation */
+    createdWallet: CreateWalletResponse | undefined;
+    /** Refetch the wallet data */
+    refetchWallet: () => Promise<void>;
+    /** Refetch the balance */
+    refetchBalance: () => Promise<void>;
+    /** Refetch both wallet and balance */
+    refetchAll: () => Promise<void>;
+}
+/**
+ * All-in-one wallet hook for Chipi SDK.
+ *
+ * Combines wallet fetching, creation, and balance checking into a single hook
+ * for simplified wallet management.
+ *
+ * @example
+ * ```tsx
+ * import { useAuth } from "@clerk/nextjs";
+ * import { useChipiWallet } from "@chipi-stack/nextjs";
+ *
+ * function WalletComponent() {
+ *   const { userId, getToken } = useAuth();
+ *   const {
+ *     wallet,
+ *     hasWallet,
+ *     balance,
+ *     formattedBalance,
+ *     createWallet,
+ *     isCreating,
+ *     isLoadingWallet,
+ *   } = useChipiWallet({
+ *     externalUserId: userId,
+ *     getBearerToken: getToken,
+ *   });
+ *
+ *   if (isLoadingWallet) return <div>Loading...</div>;
+ *
+ *   if (!hasWallet) {
+ *     return (
+ *       <button
+ *         onClick={() => createWallet({ encryptKey: "1234" })}
+ *         disabled={isCreating}
+ *       >
+ *         {isCreating ? "Creating..." : "Create Wallet"}
+ *       </button>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Address: {wallet?.shortAddress}</p>
+ *       <p>Balance: ${formattedBalance} USDC</p>
+ *       <p>Session Keys: {wallet?.supportsSessionKeys ? "Yes" : "No"}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useChipiWallet(config: UseChipiWalletConfig): UseChipiWalletReturn;
+
+/**
+ * Wallet data with optional wallet type for session operations
+ */
+interface SessionWallet extends WalletData {
+    walletType?: WalletType;
+}
+/**
+ * Configuration for useChipiSession hook
+ */
+interface UseChipiSessionConfig {
+    /** Wallet data (must be a CHIPI wallet for session support) */
+    wallet: SessionWallet | null | undefined;
+    /** Encryption key (user's PIN) for signing operations */
+    encryptKey: string;
+    /** Function to get the bearer token for API calls */
+    getBearerToken: () => Promise<string | null | undefined>;
+    /** Previously stored session data (from Clerk metadata, database, etc.) */
+    storedSession?: SessionKeyData | null;
+    /** Callback fired when a new session is created (for persistence) */
+    onSessionCreated?: (session: SessionKeyData) => void | Promise<void>;
+    /** Session duration in seconds (default: 6 hours) */
+    defaultDurationSeconds?: number;
+    /** Default max calls for session registration (default: 1000) */
+    defaultMaxCalls?: number;
+    /** Whether to auto-check session status on mount */
+    autoCheckStatus?: boolean;
+}
+/**
+ * Session lifecycle state
+ */
+type SessionState = "none" | "created" | "active" | "expired" | "revoked";
+/**
+ * Return type for useChipiSession hook
+ */
+interface UseChipiSessionReturn {
+    /** Current session key data */
+    session: SessionKeyData | null;
+    /** On-chain session status (from contract query) */
+    sessionStatus: SessionDataResponse | undefined;
+    /** Current session lifecycle state */
+    sessionState: SessionState;
+    /** Whether there is an active, usable session */
+    hasActiveSession: boolean;
+    /** Whether the session has expired */
+    isSessionExpired: boolean;
+    /** Remaining calls available for the session */
+    remainingCalls: number | undefined;
+    /** Whether the wallet supports sessions (CHIPI wallet) */
+    supportsSession: boolean;
+    /** Create a new session keypair locally (does NOT register on-chain) */
+    createSession: (config?: Partial<CreateSessionKeyParams>) => Promise<SessionKeyData>;
+    /** Register the current session on the blockchain */
+    registerSession: (config?: Partial<SessionConfig>) => Promise<string>;
+    /** Revoke the current session from the blockchain */
+    revokeSession: () => Promise<string>;
+    /** Execute calls using the session key (no owner signature needed) */
+    executeWithSession: (calls: Call[]) => Promise<string>;
+    /** Clear the current session from local state */
+    clearSession: () => void;
+    /** Refresh the on-chain session status */
+    refetchStatus: () => Promise<void>;
+    isCreating: boolean;
+    isRegistering: boolean;
+    isRevoking: boolean;
+    isExecuting: boolean;
+    isLoadingStatus: boolean;
+    error: Error | null;
+}
+/**
+ * All-in-one session management hook for Chipi SDK.
+ *
+ * Combines session creation, registration, execution, and revocation
+ * into a single unified API. Session keys enable gasless transactions
+ * without requiring the owner's private key for each operation.
+ *
+ * **Important:** Sessions only work with CHIPI wallets. ARGENT wallets
+ * do not support session keys.
+ *
+ * @example
+ * ```tsx
+ * import { useAuth } from "@clerk/nextjs";
+ * import { useChipiWallet, useChipiSession } from "@chipi-stack/nextjs";
+ *
+ * function SessionComponent() {
+ *   const { userId, getToken } = useAuth();
+ *   const [pin, setPin] = useState("");
+ *   const { wallet } = useChipiWallet({ externalUserId: userId, getBearerToken: getToken });
+ *
+ *   const {
+ *     session,
+ *     hasActiveSession,
+ *     sessionState,
+ *     createSession,
+ *     registerSession,
+ *     executeWithSession,
+ *     isCreating,
+ *     isRegistering,
+ *   } = useChipiSession({
+ *     wallet,
+ *     encryptKey: pin,
+ *     getBearerToken: getToken,
+ *     onSessionCreated: async (newSession) => {
+ *       // Persist to Clerk metadata or database
+ *       await saveSessionToClerk(newSession);
+ *     },
+ *   });
+ *
+ *   const handleSetupSession = async () => {
+ *     // Step 1: Create session locally
+ *     await createSession();
+ *     // Step 2: Register on-chain
+ *     await registerSession();
+ *   };
+ *
+ *   const handleTransfer = async () => {
+ *     // Execute transfer using session (no PIN needed after setup)
+ *     await executeWithSession([{
+ *       contractAddress: USDC_ADDRESS,
+ *       entrypoint: "transfer",
+ *       calldata: [recipient, amount, "0x0"],
+ *     }]);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Session State: {sessionState}</p>
+ *       {!hasActiveSession ? (
+ *         <button onClick={handleSetupSession} disabled={isCreating || isRegistering}>
+ *           Setup Session
+ *         </button>
+ *       ) : (
+ *         <button onClick={handleTransfer}>
+ *           Transfer (Gasless)
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useChipiSession(config: UseChipiSessionConfig): UseChipiSessionReturn;
+
 type TransferInput = {
     params: TransferHookInput;
     bearerToken: string;
@@ -1472,4 +1677,201 @@ declare function useCreateUser(): {
     reset: () => void;
 };
 
-export { useApprove, useCallAnyContract, useCreateSkuTransaction, useCreateUser, useCreateWallet, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useRecordSendTransaction, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };
+/**
+ * Hook for creating a session keypair locally.
+ *
+ * This generates session keys but does NOT register them on-chain.
+ * The returned SessionKeyData should be stored by the developer externally
+ * (e.g., in Clerk metadata, database, etc.) - the SDK does NOT persist this.
+ *
+ * After generating, call `useAddSessionKeyToContract` to register the session on-chain.
+ *
+ * @example
+ * ```typescript
+ * const { createSessionKey, data: session } = useCreateSessionKey();
+ *
+ * // Generate session keypair
+ * createSessionKey({
+ *   encryptKey: userEncryptKey,
+ *   durationSeconds: 21600 // 6 hours (optional, default)
+ * });
+ *
+ * // Store session externally after creation
+ * if (session) {
+ *   await saveToClerk(session);
+ * }
+ * ```
+ */
+declare function useCreateSessionKey(): {
+    createSessionKey: (params: CreateSessionKeyParams) => void;
+    createSessionKeyAsync: (params: CreateSessionKeyParams) => Promise<SessionKeyData>;
+    data: SessionKeyData | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type AddSessionKeyInput = {
+    params: AddSessionKeyParams;
+    bearerToken: string;
+};
+/**
+ * Hook for registering a session key on the smart contract.
+ *
+ * This executes a sponsored transaction (using owner signature) to call
+ * `add_or_update_session_key` on the CHIPI wallet contract.
+ *
+ * The session must be registered before it can be used for transactions.
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { addSessionKeyToContract, isLoading } = useAddSessionKeyToContract();
+ *
+ * // Register session on-chain
+ * addSessionKeyToContract({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     sessionConfig: {
+ *       sessionPublicKey: session.publicKey,
+ *       validUntil: session.validUntil,
+ *       maxCalls: 1000,
+ *       allowedEntrypoints: [] // empty = all allowed
+ *     }
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useAddSessionKeyToContract(): {
+    addSessionKeyToContract: (input: AddSessionKeyInput) => void;
+    addSessionKeyToContractAsync: (input: AddSessionKeyInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+type RevokeSessionKeyInput = {
+    params: RevokeSessionKeyParams;
+    bearerToken: string;
+};
+/**
+ * Hook for revoking a session key from the smart contract.
+ *
+ * This executes a sponsored transaction (using owner signature) to call
+ * `revoke_session_key` on the CHIPI wallet contract.
+ *
+ * After revocation, the session key can no longer be used for transactions.
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { revokeSessionKey, isLoading } = useRevokeSessionKey();
+ *
+ * // Revoke a session
+ * revokeSessionKey({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     sessionPublicKey: session.publicKey
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useRevokeSessionKey(): {
+    revokeSessionKey: (input: RevokeSessionKeyInput) => void;
+    revokeSessionKeyAsync: (input: RevokeSessionKeyInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+/**
+ * Hook for querying session data from the smart contract.
+ *
+ * This is a read-only call that does not require signing or gas.
+ * Returns the on-chain state of a session key including:
+ * - Whether it's active
+ * - When it expires
+ * - Remaining calls
+ * - Allowed entrypoints
+ *
+ * @example
+ * ```typescript
+ * const { data: sessionData, isLoading } = useGetSessionData({
+ *   walletAddress: userWallet.publicKey,
+ *   sessionPublicKey: session.publicKey
+ * });
+ *
+ * if (sessionData?.isActive) {
+ *   console.log(`Session has ${sessionData.remainingCalls} calls remaining`);
+ * }
+ * ```
+ */
+declare function useGetSessionData(params: GetSessionDataParams | null, options?: {
+    enabled?: boolean;
+}): {
+    data: SessionDataResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    refetch: UseQueryResult<SessionDataResponse, Error>["refetch"];
+};
+
+type ExecuteWithSessionInput = {
+    params: ExecuteWithSessionParams;
+    bearerToken: string;
+};
+/**
+ * Hook for executing a gasless transaction using a session key.
+ *
+ * This uses the 4-element session signature format instead of owner signature.
+ * The session must be:
+ * 1. Generated via `useCreateSessionKey`
+ * 2. Registered on-chain via `useAddSessionKeyToContract`
+ *
+ * Only works with CHIPI wallets.
+ *
+ * @example
+ * ```typescript
+ * const { executeWithSession, isLoading } = useExecuteWithSession();
+ *
+ * // Execute a transfer using session key (no owner key needed)
+ * executeWithSession({
+ *   params: {
+ *     encryptKey: userEncryptKey,
+ *     wallet: userWallet,
+ *     session: sessionKeyData,
+ *     calls: [{
+ *       contractAddress: USDC_ADDRESS,
+ *       entrypoint: 'transfer',
+ *       calldata: [recipient, amount, '0x0']
+ *     }]
+ *   },
+ *   bearerToken
+ * });
+ * ```
+ */
+declare function useExecuteWithSession(): {
+    executeWithSession: (input: ExecuteWithSessionInput) => void;
+    executeWithSessionAsync: (input: ExecuteWithSessionInput) => Promise<string>;
+    data: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    reset: () => void;
+};
+
+export { type ChipiWalletData, type SessionState, type SessionWallet, type UseChipiSessionConfig, type UseChipiSessionReturn, type UseChipiWalletConfig, type UseChipiWalletReturn, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateSkuTransaction, useCreateUser, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useRecordSendTransaction, useRevokeSessionKey, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };