@spacesops/wdk-react-native-core 1.0.0-beta.40

package/dist/hooks/useWdkApp.js

@@ -0,0 +1,74 @@
+/**
+ * useWdkApp Hook
+ *
+ * Hook to access WdkAppProvider context for app-level initialization state.
+ * Must be used within WdkAppProvider.
+ *
+ * Purpose: Check if the app is ready and get initialization status.
+ * - Use this to check: "Is the app ready? What's the initialization status?"
+ * - For wallet operations (addresses, account methods): Use useWallet()
+ * - For wallet lifecycle (create, load, import, delete): Use useWalletManager()
+ *
+ * @example
+ * Simple usage (most common):
+ * ```tsx
+ * import { AppStatus } from '@tetherto/wdk-react-native-core'
+ *
+ * function MyComponent() {
+ *   const { status, isReady, activeWalletId, error } = useWdkApp()
+ *
+ *   if (isReady) {
+ *     return <AppContent walletId={activeWalletId} />
+ *   }
+ *
+ *   if (status === AppStatus.ERROR) {
+ *     return <ErrorScreen error={error} />
+ *   }
+ *
+ *   return <LoadingScreen />
+ * }
+ * ```
+ *
+ * @example
+ * Advanced usage (granular control):
+ * ```tsx
+ * function MyComponent() {
+ *   const { workletState, walletState, activeWalletId } = useWdkApp()
+ *
+ *   // Show different UI based on specific states
+ *   if (workletState.isReady && walletState.status === 'not_loaded') {
+ *     return <SelectWalletScreen />
+ *   }
+ *
+ *   if (workletState.error) {
+ *     return <WorkletErrorScreen error={workletState.error} />
+ *   }
+ *
+ *   if (walletState.error) {
+ *     return <WalletErrorScreen error={walletState.error} />
+ *   }
+ *
+ *   if (walletState.status === 'ready') {
+ *     return <AppContent walletId={activeWalletId} />
+ *   }
+ *
+ *   return <LoadingScreen />
+ * }
+ * ```
+ */
+import { useContext } from 'react';
+import { WdkAppContext } from '../provider/WdkAppProvider';
+/**
+ * Hook to access WdkAppProvider context
+ *
+ * @returns WdkApp context value with initialization state
+ * @throws Error if used outside WdkAppProvider
+ */
+export function useWdkApp() {
+    const context = useContext(WdkAppContext);
+    if (!context) {
+        throw new Error('useWdkApp must be used within WdkAppProvider');
+    }
+    return context;
+}
+//# sourceMappingURL=useWdkApp.js.map

package/dist/hooks/useWdkApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWdkApp.js","sourceRoot":"","sources":["../../src/hooks/useWdkApp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAElC,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAG1D;;;;;GAKG;AACH,MAAM,UAAU,SAAS;IACvB,MAAM,OAAO,GAAG,UAAU,CAAC,aAAa,CAAC,CAAA;IACzC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAA;IACjE,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/hooks/useWorklet.d.ts

@@ -0,0 +1,66 @@
+import type { HRPC } from '@spacesops/pear-wrk-wdk';
+import type { WorkletStartResponse } from '@spacesops/pear-wrk-wdk/types/rpc';
+import type { Worklet } from '@spacesops/react-native-bare-kit';
+import type { NetworkConfigs } from '../types';
+/**
+ * Hook to interact with the worklet
+ *
+ * This is the main hook that components should use to access worklet functionality.
+ *
+ * For wallet-specific operations (addresses, accounts), use `useWallet()` hook instead.
+ *
+ * The worklet automatically starts when `WdkAppProvider` loads.
+ *
+ * @example
+ * ```tsx
+ * const { hrpc, isInitialized, isLoading, initializeWDK, generateEntropyAndEncrypt, error } = useWorklet()
+ *
+ * useEffect(() => {
+ *   if (isInitialized && !isLoading) {
+ *     // Worklet is already started by WdkAppProvider
+ *     const { encryptionKey, encryptedSeedBuffer } = await generateEntropyAndEncrypt(12)
+ *     await initializeWDK({ encryptionKey, encryptedSeed: encryptedSeedBuffer })
+ *   }
+ * }, [isInitialized, isLoading])
+ * ```
+ */
+export interface UseWorkletResult {
+    isWorkletStarted: boolean;
+    isInitialized: boolean;
+    isLoading: boolean;
+    error: string | null;
+    hrpc: HRPC | null;
+    worklet: Worklet | null;
+    workletStartResult: WorkletStartResponse | null;
+    wdkInitResult: {
+        status?: string | null;
+    } | null;
+    encryptedSeed: string | null;
+    encryptionKey: string | null;
+    networkConfigs: NetworkConfigs | null;
+    initializeWDK: (options: {
+        encryptionKey: string;
+        encryptedSeed: string;
+    }) => Promise<void>;
+    generateEntropyAndEncrypt: (wordCount?: 12 | 24) => Promise<{
+        encryptionKey: string;
+        encryptedSeedBuffer: string;
+        encryptedEntropyBuffer: string;
+    }>;
+    getMnemonicFromEntropy: (encryptedEntropy: string, encryptionKey: string) => Promise<{
+        mnemonic: string;
+    }>;
+    getSeedAndEntropyFromMnemonic: (mnemonic: string) => Promise<{
+        encryptionKey: string;
+        encryptedSeedBuffer: string;
+        encryptedEntropyBuffer: string;
+    }>;
+    initializeWorklet: (options: {
+        encryptionKey: string;
+        encryptedSeed: string;
+        networkConfigs: NetworkConfigs;
+    }) => Promise<void>;
+    reset: () => void;
+    clearError: () => void;
+}
+export declare function useWorklet(): UseWorkletResult;

package/dist/hooks/useWorklet.js

@@ -0,0 +1,42 @@
+import { useShallow } from 'zustand/react/shallow';
+import { WorkletLifecycleService } from '../services/workletLifecycleService';
+import { getWorkletStore } from '../store/workletStore';
+export function useWorklet() {
+    const store = getWorkletStore();
+    // Subscribe to state changes
+    const selector = useShallow((state) => ({
+        isWorkletStarted: state.isWorkletStarted,
+        isInitialized: state.isInitialized,
+        isLoading: state.isLoading,
+        error: state.error,
+        hrpc: state.hrpc,
+        worklet: state.worklet,
+        workletStartResult: state.workletStartResult,
+        wdkInitResult: state.wdkInitResult,
+        encryptedSeed: state.encryptedSeed,
+        encryptionKey: state.encryptionKey,
+        networkConfigs: state.networkConfigs,
+    }));
+    const workletState = store(selector);
+    return {
+        isWorkletStarted: workletState.isWorkletStarted,
+        isInitialized: workletState.isInitialized,
+        isLoading: workletState.isLoading,
+        error: workletState.error,
+        hrpc: workletState.hrpc,
+        worklet: workletState.worklet,
+        workletStartResult: workletState.workletStartResult,
+        wdkInitResult: workletState.wdkInitResult,
+        encryptedSeed: workletState.encryptedSeed,
+        encryptionKey: workletState.encryptionKey,
+        networkConfigs: workletState.networkConfigs,
+        initializeWDK: WorkletLifecycleService.initializeWDK,
+        generateEntropyAndEncrypt: WorkletLifecycleService.generateEntropyAndEncrypt,
+        getMnemonicFromEntropy: WorkletLifecycleService.getMnemonicFromEntropy,
+        getSeedAndEntropyFromMnemonic: WorkletLifecycleService.getSeedAndEntropyFromMnemonic,
+        initializeWorklet: WorkletLifecycleService.initializeWorklet,
+        reset: WorkletLifecycleService.reset,
+        clearError: WorkletLifecycleService.clearError,
+    };
+}
+//# sourceMappingURL=useWorklet.js.map

package/dist/hooks/useWorklet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorklet.js","sourceRoot":"","sources":["../../src/hooks/useWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAMlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAA;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AA6DvD,MAAM,UAAU,UAAU;IACxB,MAAM,KAAK,GAAG,eAAe,EAAE,CAAA;IAE/B,6BAA6B;IAC7B,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,KAAmB,EAAE,EAAE,CAAC,CAAC;QACpD,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,cAAc,EAAE,KAAK,CAAC,cAAc;KACrC,CAAC,CAAC,CAAA;IACH,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAA;IAEpC,OAAO;QACL,gBAAgB,EAAE,YAAY,CAAC,gBAAgB;QAC/C,aAAa,EAAE,YAAY,CAAC,aAAa;QACzC,SAAS,EAAE,YAAY,CAAC,SAAS;QACjC,KAAK,EAAE,YAAY,CAAC,KAAK;QACzB,IAAI,EAAE,YAAY,CAAC,IAAI;QACvB,OAAO,EAAE,YAAY,CAAC,OAAO;QAC7B,kBAAkB,EAAE,YAAY,CAAC,kBAAkB;QACnD,aAAa,EAAE,YAAY,CAAC,aAAa;QACzC,aAAa,EAAE,YAAY,CAAC,aAAa;QACzC,aAAa,EAAE,YAAY,CAAC,aAAa;QACzC,cAAc,EAAE,YAAY,CAAC,cAAc;QAC3C,aAAa,EAAE,uBAAuB,CAAC,aAAa;QACpD,yBAAyB,EAAE,uBAAuB,CAAC,yBAAyB;QAC5E,sBAAsB,EAAE,uBAAuB,CAAC,sBAAsB;QACtE,6BAA6B,EAAE,uBAAuB,CAAC,6BAA6B;QACpF,iBAAiB,EAAE,uBAAuB,CAAC,iBAAiB;QAC5D,KAAK,EAAE,uBAAuB,CAAC,KAAK;QACpC,UAAU,EAAE,uBAAuB,CAAC,UAAU;KAC/C,CAAA;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @tetherto/wdk-react-native-core
+ *
+ * Core functionality for React Native wallets
+ * Provides wallet management, balance fetching, and worklet operations
+ */
+export type { NetworkConfig, NetworkConfigs, TokenConfig, NetworkTokens, TokenConfigs, Wallet, WalletAddresses, WalletBalances, BalanceLoadingStates, BalanceFetchResult, TokenConfigProvider, TokenHelpers, WalletStore, } from './types';
+export type { ExtendedHRPC } from './types/hrpc';
+export { isExtendedHRPC, asExtendedHRPC } from './types/hrpc';
+export { WdkAppProvider } from './provider/WdkAppProvider';
+export type { WdkAppProviderProps, WdkAppContextValue } from './provider/WdkAppProvider';
+export { useWorklet } from './hooks/useWorklet';
+export { useWallet } from './hooks/useWallet';
+export { useWdkApp } from './hooks/useWdkApp';
+export { useWalletManager } from './hooks/useWalletManager';
+export type { UseWalletManagerResult, WalletInfo } from './hooks/useWalletManager';
+export { useBalance, useBalancesForWallet, useBalancesForWallets, useRefreshBalance, balanceQueryKeys } from './hooks/useBalance';
+export type { AccountInfo } from './store/walletStore';
+export { validateNetworkConfigs, validateTokenConfigs, validateBalanceRefreshInterval, validateAccountIndex, validateTokenAddress, } from './utils/validation';
+export { networkConfigSchema, networkConfigsSchema, tokenConfigSchema, tokenConfigsSchema, walletAddressesSchema, walletBalancesSchema, accountIndexSchema, networkNameSchema, balanceStringSchema, ethereumAddressSchema, sparkAddressSchema, addressSchema, } from './utils/schemas';
+export { isNetworkConfigs, isTokenConfigs, isEthereumAddress, isValidAccountIndex, isValidNetworkName, } from './utils/typeGuards';
+export { WorkletLifecycleService } from './services/workletLifecycleService';
+export { AddressService } from './services/addressService';
+export { AccountService } from './services/accountService';
+export { BalanceService } from './services/balanceService';
+export { WalletSetupService } from './services/walletSetupService';
+export { WalletSwitchingService } from './services/walletSwitchingService';
+export { validateMnemonic } from './utils/mnemonicUtils';
+export { convertBalanceToString, formatBalance, convertBigIntToString } from './utils/balanceUtils';
+export { normalizeError, getErrorMessage, isErrorType, createContextualError } from './utils/errorUtils';
+export type { Result } from './utils/result';
+export { ok, err, toResult, toResultSync } from './utils/result';
+export { InitializationStatus, AppStatus, isErrorStatus, isReadyStatus, isInProgressStatus, isAppReadyStatus, isAppInProgressStatus, hasWorkletStarted, canLoadWallet, hasWorkletStartedApp, canLoadWalletApp, getStatusMessage, getAppStatusMessage, getWorkletStatus, getCombinedStatus } from './utils/initializationState';

package/dist/index.js

@@ -0,0 +1,36 @@
+/**
+ * @tetherto/wdk-react-native-core
+ *
+ * Core functionality for React Native wallets
+ * Provides wallet management, balance fetching, and worklet operations
+ */
+export { isExtendedHRPC, asExtendedHRPC } from './types/hrpc';
+// Provider (main entry point)
+export { WdkAppProvider } from './provider/WdkAppProvider';
+// Hooks (public API)
+export { useWorklet } from './hooks/useWorklet';
+export { useWallet } from './hooks/useWallet';
+export { useWdkApp } from './hooks/useWdkApp';
+export { useWalletManager } from './hooks/useWalletManager';
+export { useBalance, useBalancesForWallet, useBalancesForWallets, useRefreshBalance, balanceQueryKeys } from './hooks/useBalance';
+// Validation Utilities (for validating configs before use)
+export { validateNetworkConfigs, validateTokenConfigs, validateBalanceRefreshInterval, validateAccountIndex, validateTokenAddress, } from './utils/validation';
+// Zod Schemas (for runtime validation)
+export { networkConfigSchema, networkConfigsSchema, tokenConfigSchema, tokenConfigsSchema, walletAddressesSchema, walletBalancesSchema, accountIndexSchema, networkNameSchema, balanceStringSchema, ethereumAddressSchema, sparkAddressSchema, addressSchema, } from './utils/schemas';
+// Type Guards (for runtime type checking)
+export { isNetworkConfigs, isTokenConfigs, isEthereumAddress, isValidAccountIndex, isValidNetworkName, } from './utils/typeGuards';
+// Services
+export { WorkletLifecycleService } from './services/workletLifecycleService';
+export { AddressService } from './services/addressService';
+export { AccountService } from './services/accountService';
+export { BalanceService } from './services/balanceService';
+export { WalletSetupService } from './services/walletSetupService';
+export { WalletSwitchingService } from './services/walletSwitchingService';
+// Utility Functions
+export { validateMnemonic } from './utils/mnemonicUtils';
+export { convertBalanceToString, formatBalance, convertBigIntToString } from './utils/balanceUtils';
+export { normalizeError, getErrorMessage, isErrorType, createContextualError } from './utils/errorUtils';
+export { ok, err, toResult, toResultSync } from './utils/result';
+// Initialization State Machine
+export { InitializationStatus, AppStatus, isErrorStatus, isReadyStatus, isInProgressStatus, isAppReadyStatus, isAppInProgressStatus, hasWorkletStarted, canLoadWallet, hasWorkletStartedApp, canLoadWalletApp, getStatusMessage, getAppStatusMessage, getWorkletStatus, getCombinedStatus } from './utils/initializationState';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqBH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7D,8BAA8B;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAG1D,qBAAqB;AACrB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAE3D,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAGjI,2DAA2D;AAC3D,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,8BAA8B,EAC9B,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,oBAAoB,CAAA;AAE3B,uCAAuC;AACvC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,GACd,MAAM,iBAAiB,CAAA;AAExB,0CAA0C;AAC1C,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,oBAAoB,CAAA;AAE3B,WAAW;AACX,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAA;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAA;AAE1E,oBAAoB;AACpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACnG,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAIxG,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAEhE,+BAA+B;AAC/B,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,6BAA6B,CAAA"}

package/dist/provider/WdkAppProvider.d.ts

@@ -0,0 +1,112 @@
+/**
+ * WdkAppProvider
+ *
+ * App-level orchestration provider that manages initialization state.
+ * Provides app-level status and initialization state via useWdkApp() hook.
+ *
+ * Responsibilities:
+ * - Manages worklet initialization state
+ * - Manages wallet initialization state
+ * - Provides combined app status (isReady, isInitializing, error)
+ * - Sets up QueryClientProvider for TanStack Query
+ * - Sets up SecureStorage
+ * - Handles AppState listeners for security
+ *
+ * Architecture:
+ * - Worklet state: Managed by workletStore (global, initialized once)
+ * - Wallet state: Managed by separate state machine (per-identifier, can load multiple)
+ * - Combined status: Derived from both worklet and wallet states
+ */
+import React from 'react';
+import { InitializationStatus, AppStatus } from '../utils/initializationState';
+import type { NetworkConfigs, TokenConfigs } from '../types';
+/**
+ * Context state exposed to consumers
+ *
+ * Purpose: App-level initialization state only. For wallet operations, use useWallet().
+ * For wallet lifecycle (create, load, import, delete), use useWalletManager().
+ *
+ * API Design:
+ * - `status`: Combined status for convenience (most common use case: "is app ready?")
+ * - `workletState`: Separate worklet state for flexibility (check worklet-specific conditions)
+ * - `walletState`: Separate wallet state for flexibility (check wallet-specific conditions)
+ *
+ * For simple cases, use `status`. For advanced cases needing granular control,
+ * use `workletState` and `walletState` directly.
+ */
+export interface WdkAppContextValue {
+    /**
+     * Combined app status (convenience helper)
+     * Derived from workletState and walletState.
+     * Use this for common "is app ready?" checks.
+     */
+    status: AppStatus;
+    /**
+     * Worklet initialization status (global, initialized once)
+     * Use this when you need to check worklet initialization state specifically.
+     */
+    workletStatus: InitializationStatus;
+    /**
+     * Worklet state (global, initialized once)
+     * Use this when you need to check worklet-specific conditions.
+     */
+    workletState: {
+        /** Worklet is ready (started, not loading, no error) */
+        isReady: boolean;
+        /** Worklet is currently loading */
+        isLoading: boolean;
+        /** Worklet error message (null if no error) */
+        error: string | null;
+    };
+    /**
+     * Wallet state (per-identifier, can load multiple wallets)
+     * Use this when you need to check wallet-specific conditions.
+     */
+    walletState: {
+        /** Current wallet state */
+        status: 'not_loaded' | 'checking' | 'loading' | 'ready' | 'error';
+        /** Wallet identifier being operated on (null if not_loaded) */
+        identifier: string | null;
+        /** Wallet error (null if no error) */
+        error: Error | null;
+    };
+    /** Initialization in progress (convenience getter, equivalent to isInProgressStatus(status)) */
+    isInitializing: boolean;
+    /** App is ready (convenience getter, equivalent to isReadyStatus(status)) */
+    isReady: boolean;
+    /** Currently active wallet identifier from walletStore (null if no wallet is loaded) */
+    activeWalletId: string | null;
+    /** Wallet identifier being loaded (transient, only during loading operations) */
+    loadingWalletId: string | null;
+    /** Whether the wallet being loaded exists in secure storage (null = not checked yet, true = exists, false = doesn't exist) */
+    walletExists: boolean | null;
+    /** Initialization error if any (worklet or wallet error) - convenience getter */
+    error: Error | null;
+    /** Retry initialization after an error */
+    retry: () => void;
+}
+declare const WdkAppContext: React.Context<WdkAppContextValue | null>;
+/**
+ * Provider props
+ */
+export interface WdkAppProviderProps {
+    /** Network configurations */
+    networkConfigs: NetworkConfigs;
+    /** Token configurations for balance fetching */
+    tokenConfigs: TokenConfigs;
+    /** Enable automatic wallet initialization on app restart (default: true) */
+    enableAutoInitialization?: boolean;
+    /**
+     * Current user's identifier (typically email)
+     * Auto-initialization will NOT proceed if:
+     * - currentUserId is undefined/null (user identity not yet confirmed)
+     * - currentUserId doesn't match activeWalletId (wrong user's wallet)
+     *
+     * This prevents initializing with wrong user's wallet during account switches
+     */
+    currentUserId?: string | null;
+    /** Child components (app content) */
+    children: React.ReactNode;
+}
+export declare function WdkAppProvider({ networkConfigs, tokenConfigs, enableAutoInitialization, currentUserId, children, }: WdkAppProviderProps): React.JSX.Element;
+export { WdkAppContext };