@zerodev/wallet-react 0.0.1-alpha.1 → 0.0.1-alpha.10

package/dist/_cjs/oauth.js

@@ -1,42 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OAUTH_PROVIDERS = void 0;
-exports.buildOAuthUrl = buildOAuthUrl;
 exports.openOAuthPopup = openOAuthPopup;
-exports.extractOAuthToken = extractOAuthToken;
-exports.pollOAuthPopup = pollOAuthPopup;
 exports.generateOAuthNonce = generateOAuthNonce;
+exports.buildBackendOAuthUrl = buildBackendOAuthUrl;
+exports.listenForOAuthMessage = listenForOAuthMessage;
+exports.handleOAuthCallback = handleOAuthCallback;
 const viem_1 = require("viem");
 exports.OAUTH_PROVIDERS = {
     GOOGLE: 'google',
 };
-const GOOGLE_AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
 const POPUP_WIDTH = 500;
 const POPUP_HEIGHT = 600;
-function buildOAuthUrl(params) {
-    const { provider, clientId, redirectUri, nonce, state } = params;
-    if (provider !== exports.OAUTH_PROVIDERS.GOOGLE) {
-        throw new Error(`Unsupported OAuth provider: ${provider}`);
-    }
-    const authUrl = new URL(GOOGLE_AUTH_URL);
-    authUrl.searchParams.set('client_id', clientId);
-    authUrl.searchParams.set('redirect_uri', redirectUri);
-    authUrl.searchParams.set('response_type', 'id_token');
-    authUrl.searchParams.set('scope', 'openid email profile');
-    authUrl.searchParams.set('nonce', nonce);
-    authUrl.searchParams.set('prompt', 'select_account');
-    let stateParam = `provider=${provider}`;
-    if (state) {
-        const additionalState = Object.entries(state)
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('&');
-        if (additionalState) {
-            stateParam += `&${additionalState}`;
-        }
-    }
-    authUrl.searchParams.set('state', stateParam);
-    return authUrl.toString();
-}
 function openOAuthPopup(url) {
     const width = POPUP_WIDTH;
     const height = POPUP_HEIGHT;
@@ -48,37 +23,67 @@ function openOAuthPopup(url) {
     }
     return authWindow;
 }
-function extractOAuthToken(url) {
-    const hashParams = new URLSearchParams(url.split('#')[1]);
-    let idToken = hashParams.get('id_token');
-    if (!idToken) {
-        const queryParams = new URLSearchParams(url.split('?')[1]);
-        idToken = queryParams.get('id_token');
+function generateOAuthNonce(publicKey) {
+    return (0, viem_1.sha256)(publicKey).replace(/^0x/, '');
+}
+function buildBackendOAuthUrl(params) {
+    const { provider, backendUrl, projectId, publicKey, returnTo } = params;
+    if (provider !== exports.OAUTH_PROVIDERS.GOOGLE) {
+        throw new Error(`Unsupported OAuth provider: ${provider}`);
     }
-    return idToken;
+    const oauthUrl = new URL(`${backendUrl}/oauth/google/login`);
+    oauthUrl.searchParams.set('project_id', projectId);
+    oauthUrl.searchParams.set('pub_key', publicKey.replace(/^0x/, ''));
+    oauthUrl.searchParams.set('return_to', returnTo);
+    return oauthUrl.toString();
 }
-function pollOAuthPopup(authWindow, originUrl, onSuccess, onError) {
-    const interval = setInterval(() => {
-        try {
-            if (authWindow.closed) {
-                clearInterval(interval);
-                onError(new Error('Authentication window was closed'));
-                return;
-            }
-            const url = authWindow.location.href || '';
-            if (url.startsWith(originUrl)) {
-                const token = extractOAuthToken(url);
-                if (token) {
-                    authWindow.close();
-                    clearInterval(interval);
-                    onSuccess(token);
-                }
-            }
+function listenForOAuthMessage(authWindow, expectedOrigin, onSuccess, onError) {
+    let cleaned = false;
+    const handleMessage = (event) => {
+        if (event.origin !== expectedOrigin)
+            return;
+        if (!event.data || typeof event.data !== 'object')
+            return;
+        if (event.data.type === 'oauth_success') {
+            cleanup();
+            onSuccess();
         }
-        catch {
+        else if (event.data.type === 'oauth_error') {
+            cleanup();
+            onError(new Error(event.data.error || 'OAuth authentication failed'));
+        }
+    };
+    const checkWindowClosed = setInterval(() => {
+        if (authWindow.closed) {
+            cleanup();
+            onError(new Error('Authentication window was closed'));
         }
     }, 500);
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        window.removeEventListener('message', handleMessage);
+        clearInterval(checkWindowClosed);
+    };
+    window.addEventListener('message', handleMessage);
+    return cleanup;
 }
-function generateOAuthNonce(publicKey) {
-    return (0, viem_1.sha256)(publicKey).replace(/^0x/, '');
+function handleOAuthCallback(successParam = 'oauth_success') {
+    const urlParams = new URLSearchParams(window.location.search);
+    const isSuccess = urlParams.get(successParam) === 'true';
+    const error = urlParams.get('error');
+    if (window.opener) {
+        if (isSuccess) {
+            window.opener.postMessage({ type: 'oauth_success' }, window.location.origin);
+            window.close();
+            return true;
+        }
+        if (error) {
+            window.opener.postMessage({ type: 'oauth_error', error }, window.location.origin);
+            window.close();
+            return false;
+        }
+    }
+    return false;
 }

package/dist/_cjs/provider.js

@@ -77,7 +77,10 @@ function createProvider({ store, config, }) {
         },
         async request({ method, params }) {
             const state = store.getState();
-            const activeChainId = state.chainIds[0];
+            const activeChainId = state.activeChainId;
+            if (!activeChainId) {
+                throw new Error('No active chain');
+            }
             switch (method) {
                 case 'eth_accounts': {
                     const account = state.kernelAccounts.get(activeChainId);
@@ -151,7 +154,7 @@ function createProvider({ store, config, }) {
                     }
                     const [{ chainId }] = params;
                     const chainId_number = parseInt(chainId, 16);
-                    store.getState().setActiveChain(chainId_number);
+                    store.getState().setActiveChainId(chainId_number);
                     emitter.emit('chainChanged', chainId);
                     return null;
                 }

package/dist/_cjs/store.js

@@ -7,7 +7,7 @@ const createZeroDevWalletStore = () => (0, zustand_1.create)()((0, middleware_1.
     wallet: null,
     eoaAccount: null,
     session: null,
-    chainIds: [],
+    activeChainId: null,
     kernelAccounts: new Map(),
     kernelClients: new Map(),
     isExpiring: false,
@@ -25,12 +25,7 @@ const createZeroDevWalletStore = () => (0, zustand_1.create)()((0, middleware_1.
         set({ kernelClients: clients });
     },
     setSession: (session) => set({ session }),
-    setActiveChain: (chainId) => {
-        const { chainIds } = get();
-        set({
-            chainIds: [chainId, ...chainIds.filter((id) => id !== chainId)],
-        });
-    },
+    setActiveChainId: (chainId) => set({ activeChainId: chainId }),
     setIsExpiring: (isExpiring) => set({ isExpiring }),
     setOAuthConfig: (config) => set({ oauthConfig: config }),
     clear: () => set({
@@ -39,13 +34,13 @@ const createZeroDevWalletStore = () => (0, zustand_1.create)()((0, middleware_1.
         kernelAccounts: new Map(),
         kernelClients: new Map(),
         isExpiring: false,
-        chainIds: [],
+        activeChainId: null,
     }),
 }), {
     name: 'zerodev-wallet',
     partialize: (state) => ({
         session: state.session,
-        chainIds: state.chainIds,
+        activeChainId: state.activeChainId,
     }),
 })));
 exports.createZeroDevWalletStore = createZeroDevWalletStore;

package/dist/_esm/actions.js

@@ -1,5 +1,6 @@
 import { connect as wagmiConnect } from '@wagmi/core/actions';
-import { buildOAuthUrl, generateOAuthNonce, openOAuthPopup, pollOAuthPopup, } from './oauth.js';
+import { createIframeStamper, exportPrivateKey as exportPrivateKeySdk, exportWallet as exportWalletSdk, } from '@zerodev/wallet-core';
+import { buildBackendOAuthUrl, listenForOAuthMessage, openOAuthPopup, } from './oauth.js';
 /**
  * Get ZeroDev connector from config
  */
@@ -60,6 +61,7 @@ export async function loginPasskey(config, parameters) {
 }
 /**
  * Authenticate with OAuth (opens popup)
+ * Uses backend OAuth flow where the backend handles PKCE and token exchange
  */
 export async function authenticateOAuth(config, parameters) {
     const connector = parameters.connector ?? getZeroDevConnector(config);
@@ -70,46 +72,36 @@ export async function authenticateOAuth(config, parameters) {
     if (!wallet)
         throw new Error('Wallet not initialized');
     if (!oauthConfig) {
-        throw new Error('OAuth is not configured. Please provide oauthConfig to zeroDevWallet connector.');
+        throw new Error('Wallet not initialized. Please wait for connector setup.');
     }
-    // Get client ID for the provider
-    let clientId = parameters.clientId;
-    if (!clientId) {
-        clientId = oauthConfig.googleClientId;
-    }
-    if (!clientId) {
-        throw new Error(`Client ID not configured for ${parameters.provider}`);
-    }
-    if (!oauthConfig.redirectUri) {
-        throw new Error('OAuth redirect URI is not configured.');
-    }
-    // Generate nonce from wallet public key
+    // Get wallet public key for the OAuth flow
     const publicKey = await wallet.getPublicKey();
     if (!publicKey) {
         throw new Error('Failed to get wallet public key');
     }
-    const nonce = generateOAuthNonce(publicKey);
-    // Build OAuth URL
-    const oauthUrl = buildOAuthUrl({
+    // Build OAuth URL that redirects to backend
+    // Use current origin as redirect - SDK auto-detects callback on any page
+    const oauthUrl = buildBackendOAuthUrl({
         provider: parameters.provider,
-        clientId,
-        redirectUri: oauthConfig.redirectUri,
-        nonce,
+        backendUrl: oauthConfig.backendUrl,
+        projectId: oauthConfig.projectId,
+        publicKey,
+        returnTo: `${window.location.origin}?oauth_success=true&oauth_provider=${parameters.provider}`,
     });
     // Open popup
     const authWindow = openOAuthPopup(oauthUrl);
     if (!authWindow) {
         throw new Error(`Failed to open ${parameters.provider} login window.`);
     }
-    // Poll for OAuth completion
+    // Listen for OAuth completion via postMessage
     return new Promise((resolve, reject) => {
-        pollOAuthPopup(authWindow, window.location.origin, async (idToken) => {
+        const cleanup = listenForOAuthMessage(authWindow, window.location.origin, async () => {
             try {
                 // Complete OAuth authentication with wallet-core
+                // The backend has stored the OAuth session in a cookie
                 await wallet.auth({
                     type: 'oauth',
                     provider: parameters.provider,
-                    credential: idToken,
                 });
                 const [session, eoaAccount] = await Promise.all([
                     wallet.getSession(),
@@ -124,7 +116,10 @@ export async function authenticateOAuth(config, parameters) {
             catch (err) {
                 reject(err);
             }
-        }, reject);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
     });
 }
 /**
@@ -148,7 +143,6 @@ export async function sendOTP(config, parameters) {
     });
     return {
         otpId: result.otpId,
-        subOrganizationId: result.subOrganizationId,
     };
 }
 /**
@@ -166,7 +160,6 @@ export async function verifyOTP(config, parameters) {
         mode: 'verifyOtp',
         otpId: parameters.otpId,
         otpCode: parameters.code,
-        subOrganizationId: parameters.subOrganizationId,
     });
     const [session, eoaAccount] = await Promise.all([
         wallet.getSession(),
@@ -193,6 +186,31 @@ export async function refreshSession(config, parameters = {}) {
     store.getState().setSession(newSession || null);
     return newSession;
 }
+/**
+ * Get user email
+ */
+export async function getUserEmail(config) {
+    const connector = getZeroDevConnector(config);
+    // @ts-expect-error - getStore is a custom method
+    const store = await connector.getStore();
+    const wallet = store.getState().wallet;
+    if (!wallet)
+        throw new Error('Wallet not initialized');
+    const oauthConfig = store.getState().oauthConfig;
+    if (!oauthConfig) {
+        throw new Error('Wallet not initialized. Please wait for connector setup.');
+    }
+    const session = store.getState().session;
+    if (!session) {
+        throw new Error('No active session');
+    }
+    // Call the core SDK method
+    return await wallet.client.getUserEmail({
+        organizationId: session.organizationId,
+        projectId: oauthConfig.projectId,
+        token: session.token,
+    });
+}
 /**
  * Export wallet
  */
@@ -203,7 +221,6 @@ export async function exportWallet(config, parameters) {
     const wallet = store.getState().wallet;
     if (!wallet)
         throw new Error('Wallet not initialized');
-    const { exportWallet: exportWalletSdk, createIframeStamper } = await import('@zerodev/wallet-core');
     const iframeContainer = document.getElementById(parameters.iframeContainerId);
     if (!iframeContainer) {
         throw new Error('Iframe container not found');
@@ -223,3 +240,33 @@ export async function exportWallet(config, parameters) {
         throw new Error('Failed to inject export bundle');
     }
 }
+/**
+ * Export private key
+ */
+export async function exportPrivateKey(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    // @ts-expect-error - getStore is a custom method
+    const store = await connector.getStore();
+    const wallet = store.getState().wallet;
+    if (!wallet)
+        throw new Error('Wallet not initialized');
+    const iframeContainer = document.getElementById(parameters.iframeContainerId);
+    if (!iframeContainer) {
+        throw new Error('Iframe container not found');
+    }
+    const iframeStamper = await createIframeStamper({
+        iframeUrl: 'https://export.turnkey.com',
+        iframeContainer,
+        iframeElementId: 'export-private-key-iframe',
+    });
+    const publicKey = await iframeStamper.init();
+    const { exportBundle, organizationId } = await exportPrivateKeySdk({
+        wallet,
+        targetPublicKey: publicKey,
+        ...(parameters.address && { address: parameters.address }),
+    });
+    const success = await iframeStamper.injectKeyExportBundle(exportBundle, organizationId, parameters.keyFormat ?? 'Hexadecimal');
+    if (success !== true) {
+        throw new Error('Failed to inject export bundle');
+    }
+}

package/dist/_esm/connector.js

@@ -1,61 +1,105 @@
 import { createConnector } from '@wagmi/core';
 import { createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient, } from '@zerodev/sdk';
 import { getEntryPoint, KERNEL_V3_3 } from '@zerodev/sdk/constants';
-import { createZeroDevWallet } from '@zerodev/wallet-core';
+import { createZeroDevWallet, KMS_SERVER_URL } from '@zerodev/wallet-core';
 import { createPublicClient, http } from 'viem';
+import { handleOAuthCallback } from './oauth.js';
 import { createProvider } from './provider.js';
 import { createZeroDevWalletStore } from './store.js';
 import { getAAUrl } from './utils/aaUtils.js';
+// OAuth URL parameter used to detect callback
+const OAUTH_SUCCESS_PARAM = 'oauth_success';
+const OAUTH_PROVIDER_PARAM = 'oauth_provider';
+/**
+ * Detect OAuth callback from URL params and handle it.
+ * - If in popup: sends postMessage to opener and closes
+ * - If not in popup: completes auth directly
+ */
+async function detectAndHandleOAuthCallback(wallet, store) {
+    if (typeof window === 'undefined')
+        return false;
+    const params = new URLSearchParams(window.location.search);
+    const isOAuthCallback = params.get(OAUTH_SUCCESS_PARAM) === 'true';
+    if (!isOAuthCallback)
+        return false;
+    // If in popup, use the existing handler to notify opener
+    if (window.opener) {
+        handleOAuthCallback(OAUTH_SUCCESS_PARAM);
+        return true;
+    }
+    // Not in popup - complete auth directly (redirect flow)
+    console.log('OAuth callback detected, completing authentication...');
+    const provider = (params.get(OAUTH_PROVIDER_PARAM) ||
+        'google');
+    try {
+        await wallet.auth({ type: 'oauth', provider });
+        const [session, eoaAccount] = await Promise.all([
+            wallet.getSession(),
+            wallet.toAccount(),
+        ]);
+        store.getState().setEoaAccount(eoaAccount);
+        store.getState().setSession(session || null);
+        // Clean up URL params
+        params.delete(OAUTH_SUCCESS_PARAM);
+        params.delete(OAUTH_PROVIDER_PARAM);
+        const newUrl = params.toString()
+            ? `${window.location.pathname}?${params.toString()}`
+            : window.location.pathname;
+        window.history.replaceState({}, '', newUrl);
+        console.log('OAuth authentication completed');
+        return true;
+    }
+    catch (error) {
+        console.error('OAuth authentication failed:', error);
+        return false;
+    }
+}
 export function zeroDevWallet(params) {
     return createConnector((wagmiConfig) => {
         let store;
         let provider;
-        let initPromise;
         // Get transports from Wagmi config (uses user's RPC URLs)
         const transports = wagmiConfig.transports;
         // Lazy initialization - only runs on client side
         const initialize = async () => {
-            initPromise ??= (async () => {
-                console.log('Initializing ZeroDevWallet connector...');
-                // Initialize wallet SDK
-                const wallet = await createZeroDevWallet({
-                    projectId: params.projectId,
-                    ...(params.organizationId && {
-                        organizationId: params.organizationId,
-                    }),
-                    ...(params.proxyBaseUrl && { proxyBaseUrl: params.proxyBaseUrl }),
-                    ...(params.sessionStorage && {
-                        sessionStorage: params.sessionStorage,
-                    }),
-                    ...(params.rpId && { rpId: params.rpId }),
-                });
-                // Create store
-                store = createZeroDevWalletStore();
-                store.getState().setWallet(wallet);
-                // Initialize chainIds
-                const chainIds = params.chains.map((c) => c.id);
-                store.setState({ chainIds });
-                // Store OAuth config if provided
-                if (params.oauthConfig) {
-                    store.getState().setOAuthConfig(params.oauthConfig);
-                }
-                // Create EIP-1193 provider
-                provider = createProvider({
-                    store,
-                    config: params,
-                    chains: Array.from(params.chains),
-                });
-                // Check for existing session (page reload)
-                const session = await wallet.getSession();
-                if (session) {
-                    console.log('Found existing session, restoring...');
-                    const eoaAccount = await wallet.toAccount();
-                    store.getState().setEoaAccount(eoaAccount);
-                    store.getState().setSession(session);
-                }
-                console.log('ZeroDevWallet connector initialized');
-            })();
-            return initPromise;
+            console.log('Initializing ZeroDevWallet connector...');
+            // Initialize wallet SDK
+            const wallet = await createZeroDevWallet({
+                projectId: params.projectId,
+                ...(params.organizationId && {
+                    organizationId: params.organizationId,
+                }),
+                ...(params.proxyBaseUrl && { proxyBaseUrl: params.proxyBaseUrl }),
+                ...(params.sessionStorage && {
+                    sessionStorage: params.sessionStorage,
+                }),
+                ...(params.rpId && { rpId: params.rpId }),
+            });
+            // Create store
+            store = createZeroDevWalletStore();
+            store.getState().setWallet(wallet);
+            // Store OAuth config - uses proxyBaseUrl and projectId from params
+            store.getState().setOAuthConfig({
+                backendUrl: params.proxyBaseUrl || `${KMS_SERVER_URL}/api/v1`,
+                projectId: params.projectId,
+            });
+            // Create EIP-1193 provider
+            provider = createProvider({
+                store,
+                config: params,
+                chains: Array.from(params.chains),
+            });
+            // Check for existing session (page reload)
+            const session = await wallet.getSession();
+            if (session) {
+                console.log('Found existing session, restoring...');
+                const eoaAccount = await wallet.toAccount();
+                store.getState().setEoaAccount(eoaAccount);
+                store.getState().setSession(session);
+            }
+            // Auto-detect OAuth callback (when popup redirects back with ?oauth_success=true)
+            await detectAndHandleOAuthCallback(wallet, store);
+            console.log('ZeroDevWallet connector initialized');
         };
         return {
             id: 'zerodev-wallet',
@@ -77,10 +121,7 @@ export function zeroDevWallet(params) {
                     : 'Connecting ZeroDevWallet...');
                 const state = store.getState();
                 // Determine active chain
-                const activeChainId = chainId || state.chainIds[0];
-                if (!activeChainId) {
-                    throw new Error('No chain configured');
-                }
+                const activeChainId = chainId ?? state.activeChainId ?? params.chains[0].id;
                 // If reconnecting and already have kernel account, return immediately
                 if (isReconnecting && state.kernelAccounts.has(activeChainId)) {
                     const kernelAccount = state.kernelAccounts.get(activeChainId);
@@ -129,7 +170,7 @@ export function zeroDevWallet(params) {
                     store.getState().setKernelClient(activeChainId, kernelClient);
                 }
                 // Set as active chain
-                store.getState().setActiveChain(activeChainId);
+                store.getState().setActiveChainId(activeChainId);
                 // Get fresh state after updates
                 const freshState = store.getState();
                 const kernelAccount = freshState.kernelAccounts.get(activeChainId);
@@ -155,35 +196,36 @@ export function zeroDevWallet(params) {
             async getAccounts() {
                 if (!store)
                     return [];
-                const { eoaAccount, kernelAccounts, chainIds } = store.getState();
+                const { eoaAccount, kernelAccounts, activeChainId } = store.getState();
                 // Return EOA address if we have it (EIP-7702: EOA address = kernel address)
                 if (eoaAccount) {
                     return [eoaAccount.address];
                 }
                 // Fallback: check kernel accounts
-                const activeAccount = chainIds[0]
-                    ? kernelAccounts.get(chainIds[0])
+                const activeAccount = activeChainId
+                    ? kernelAccounts.get(activeChainId)
                     : null;
                 return activeAccount ? [activeAccount.address] : [];
             },
             async getChainId() {
                 if (!store)
                     return params.chains[0].id;
-                return store.getState().chainIds[0] || params.chains[0].id;
+                return store.getState().activeChainId ?? params.chains[0].id;
             },
             async getProvider() {
-                await initialize();
+                if (!provider) {
+                    await initialize();
+                }
                 return provider;
             },
             async switchChain({ chainId }) {
-                await initialize();
                 console.log(`Switching to chain ${chainId}...`);
                 const state = store.getState();
                 if (!state.eoaAccount) {
                     throw new Error('Not authenticated');
                 }
                 // Update active chain
-                store.getState().setActiveChain(chainId);
+                store.getState().setActiveChainId(chainId);
                 // Create kernel account for new chain if doesn't exist
                 if (!state.kernelAccounts.has(chainId)) {
                     const chain = params.chains.find((c) => c.id === chainId);
@@ -215,6 +257,7 @@ export function zeroDevWallet(params) {
                     });
                     store.getState().setKernelClient(chainId, kernelClient);
                 }
+                wagmiConfig.emitter.emit('change', { chainId });
                 return params.chains.find((c) => c.id === chainId);
             },
             async isAuthorized() {

package/dist/_esm/hooks/useExportPrivateKey.js

@@ -0,0 +1,18 @@
+'use client';
+import { useMutation, } from '@tanstack/react-query';
+import { useConfig } from 'wagmi';
+import { exportPrivateKey } from '../actions.js';
+/**
+ * Hook to export private key
+ */
+export function useExportPrivateKey(parameters = {}) {
+    const { mutation } = parameters;
+    const config = useConfig(parameters);
+    return useMutation({
+        ...mutation,
+        async mutationFn(variables) {
+            return exportPrivateKey(config, variables);
+        },
+        mutationKey: ['exportPrivateKey'],
+    });
+}

package/dist/_esm/hooks/useGetUserEmail.js

@@ -0,0 +1,19 @@
+'use client';
+import { useQuery, } from '@tanstack/react-query';
+import { useConfig } from 'wagmi';
+import { getUserEmail } from '../actions.js';
+/**
+ * Hook to fetch user email address
+ */
+export function useGetUserEmail(parameters) {
+    const { query } = parameters;
+    const config = useConfig(parameters);
+    return useQuery({
+        ...query,
+        queryKey: ['getUserEmail'],
+        queryFn: async () => {
+            return getUserEmail(config);
+        },
+        enabled: Boolean(config),
+    });
+}

package/dist/_esm/index.js

@@ -1,10 +1,12 @@
 export { zeroDevWallet } from './connector.js';
 export { useAuthenticateOAuth } from './hooks/useAuthenticateOAuth.js';
+export { useExportPrivateKey } from './hooks/useExportPrivateKey.js';
 export { useExportWallet } from './hooks/useExportWallet.js';
+export { useGetUserEmail } from './hooks/useGetUserEmail.js';
 export { useLoginPasskey } from './hooks/useLoginPasskey.js';
 export { useRefreshSession } from './hooks/useRefreshSession.js';
 export { useRegisterPasskey } from './hooks/useRegisterPasskey.js';
 export { useSendOTP } from './hooks/useSendOTP.js';
 export { useVerifyOTP } from './hooks/useVerifyOTP.js';
-export { OAUTH_PROVIDERS } from './oauth.js';
+export { buildBackendOAuthUrl, handleOAuthCallback, listenForOAuthMessage, OAUTH_PROVIDERS, } from './oauth.js';
 export { createZeroDevWalletStore } from './store.js';