@zerodev/wallet-react 0.0.1-alpha.0

package/dist/_cjs/provider.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProvider = createProvider;
+const wallet_core_1 = require("@zerodev/wallet-core");
+const ox_1 = require("ox");
+const SESSION_WARNING_THRESHOLD_MS = 60 * 1000;
+function createProvider({ store, config, }) {
+    const emitter = ox_1.Provider.createEmitter();
+    let sessionRefreshTimer = null;
+    const scheduleSessionRefresh = () => {
+        if (config.autoRefreshSession === false)
+            return;
+        const state = store.getState();
+        if (!state.session || !state.wallet)
+            return;
+        const expiryMs = (0, wallet_core_1.normalizeTimestamp)(state.session.expiry);
+        const now = Date.now();
+        const timeUntilExpiry = expiryMs - now;
+        if (timeUntilExpiry <= 0) {
+            console.log('Session already expired');
+            return;
+        }
+        if (sessionRefreshTimer) {
+            clearTimeout(sessionRefreshTimer);
+            sessionRefreshTimer = null;
+        }
+        const threshold = config.sessionWarningThreshold || SESSION_WARNING_THRESHOLD_MS;
+        const refreshAt = expiryMs - threshold;
+        const timeUntilRefresh = refreshAt - now;
+        if (timeUntilRefresh <= 0) {
+            console.log('Session expiring soon, refreshing immediately...');
+            refreshSessionNow();
+        }
+        else {
+            console.log(`Scheduling session refresh in ${timeUntilRefresh}ms`);
+            sessionRefreshTimer = setTimeout(() => {
+                refreshSessionNow();
+            }, timeUntilRefresh);
+        }
+    };
+    const refreshSessionNow = async () => {
+        const state = store.getState();
+        if (!state.wallet || !state.session)
+            return;
+        console.log('Auto-refreshing session...');
+        store.getState().setIsExpiring(true);
+        try {
+            const newSession = await state.wallet.refreshSession(state.session.id);
+            console.log('Session refreshed successfully');
+            store.getState().setSession(newSession || null);
+            store.getState().setIsExpiring(false);
+            if (newSession) {
+                scheduleSessionRefresh();
+            }
+        }
+        catch (err) {
+            console.error('Session refresh failed:', err);
+            store.getState().setIsExpiring(false);
+            store.getState().clear();
+        }
+    };
+    const unsubscribe = store.subscribe((state) => state.session, () => {
+        scheduleSessionRefresh();
+    });
+    const initialSession = store.getState().session;
+    if (initialSession) {
+        scheduleSessionRefresh();
+    }
+    return {
+        ...emitter,
+        destroy() {
+            if (sessionRefreshTimer) {
+                clearTimeout(sessionRefreshTimer);
+                sessionRefreshTimer = null;
+            }
+            unsubscribe();
+        },
+        async request({ method, params }) {
+            const state = store.getState();
+            const activeChainId = state.chainIds[0];
+            switch (method) {
+                case 'eth_accounts': {
+                    const account = state.kernelAccounts.get(activeChainId);
+                    return account ? [account.address] : [];
+                }
+                case 'eth_requestAccounts': {
+                    const account = state.kernelAccounts.get(activeChainId);
+                    if (!account)
+                        throw new Error('Not authenticated');
+                    return [account.address];
+                }
+                case 'eth_chainId': {
+                    return `0x${activeChainId.toString(16)}`;
+                }
+                case 'wallet_sendTransaction':
+                case 'eth_sendTransaction': {
+                    if (!params || params.length === 0) {
+                        throw new Error('Missing transaction parameters');
+                    }
+                    const [tx] = params;
+                    const chainId = tx.chainId ? parseInt(tx.chainId, 16) : activeChainId;
+                    const kernelClient = store.getState().kernelClients.get(chainId);
+                    if (!kernelClient) {
+                        throw new Error(`No kernel client for chain ${chainId}`);
+                    }
+                    const hash = await kernelClient.sendTransaction({
+                        calls: [
+                            {
+                                to: tx.to,
+                                value: tx.value ? BigInt(tx.value) : 0n,
+                                data: tx.data || '0x',
+                            },
+                        ],
+                    });
+                    return hash;
+                }
+                case 'personal_sign': {
+                    if (!params || params.length < 2) {
+                        throw new Error('Missing sign parameters');
+                    }
+                    const [message] = params;
+                    let account = state.kernelAccounts.get(activeChainId);
+                    if (account &&
+                        'isDeployed' in account &&
+                        !(await account.isDeployed())) {
+                        account = state.eoaAccount;
+                    }
+                    if (!account)
+                        throw new Error('Not authenticated');
+                    return await account.signMessage({ message });
+                }
+                case 'eth_signTypedData_v4': {
+                    if (!params || params.length < 2) {
+                        throw new Error('Missing typed data parameters');
+                    }
+                    const [, typedDataJson] = params;
+                    let account = state.kernelAccounts.get(activeChainId);
+                    if (account &&
+                        'isDeployed' in account &&
+                        !(await account.isDeployed())) {
+                        account = state.eoaAccount;
+                    }
+                    if (!account)
+                        throw new Error('Not authenticated');
+                    const typedData = JSON.parse(typedDataJson);
+                    return await account.signTypedData(typedData);
+                }
+                case 'wallet_switchEthereumChain': {
+                    if (!params || params.length === 0) {
+                        throw new Error('Missing chain parameter');
+                    }
+                    const [{ chainId }] = params;
+                    const chainId_number = parseInt(chainId, 16);
+                    store.getState().setActiveChain(chainId_number);
+                    emitter.emit('chainChanged', chainId);
+                    return null;
+                }
+                default:
+                    throw new Error(`Method not supported: ${method}`);
+            }
+        },
+    };
+}

package/dist/_cjs/store.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZeroDevWalletStore = void 0;
+const zustand_1 = require("zustand");
+const middleware_1 = require("zustand/middleware");
+const createZeroDevWalletStore = () => (0, zustand_1.create)()((0, middleware_1.subscribeWithSelector)((0, middleware_1.persist)((set, get) => ({
+    wallet: null,
+    eoaAccount: null,
+    session: null,
+    chainIds: [],
+    kernelAccounts: new Map(),
+    kernelClients: new Map(),
+    isExpiring: false,
+    oauthConfig: null,
+    setWallet: (wallet) => set({ wallet }),
+    setEoaAccount: (account) => set({ eoaAccount: account }),
+    setKernelAccount: (chainId, account) => {
+        const accounts = new Map(get().kernelAccounts);
+        accounts.set(chainId, account);
+        set({ kernelAccounts: accounts });
+    },
+    setKernelClient: (chainId, client) => {
+        const clients = new Map(get().kernelClients);
+        clients.set(chainId, client);
+        set({ kernelClients: clients });
+    },
+    setSession: (session) => set({ session }),
+    setActiveChain: (chainId) => {
+        const { chainIds } = get();
+        set({
+            chainIds: [chainId, ...chainIds.filter((id) => id !== chainId)],
+        });
+    },
+    setIsExpiring: (isExpiring) => set({ isExpiring }),
+    setOAuthConfig: (config) => set({ oauthConfig: config }),
+    clear: () => set({
+        eoaAccount: null,
+        session: null,
+        kernelAccounts: new Map(),
+        kernelClients: new Map(),
+        isExpiring: false,
+        chainIds: [],
+    }),
+}), {
+    name: 'zerodev-wallet',
+    partialize: (state) => ({
+        session: state.session,
+        chainIds: state.chainIds,
+    }),
+})));
+exports.createZeroDevWalletStore = createZeroDevWalletStore;

package/dist/_cjs/utils/aaUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAAUrl = getAAUrl;
+const constants_js_1 = require("../constants.js");
+function getAAUrl(chainId, aaUrl) {
+    return aaUrl || `${constants_js_1.ZERODEV_AA_URL}${chainId}/chain/${chainId}`;
+}

package/dist/_cjs/utils/timers.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DELAY_MS = void 0;
+exports.setCappedTimeout = setCappedTimeout;
+exports.putTimer = putTimer;
+exports.clearKey = clearKey;
+exports.clearAll = clearAll;
+exports.setCappedTimeoutInMap = setCappedTimeoutInMap;
+exports.MAX_DELAY_MS = 2_147_483_647;
+function toIntMs(x) {
+    return Math.max(0, Math.floor(Number.isFinite(x) ? x : 0));
+}
+function setCappedTimeout(cb, delayMs) {
+    const target = Date.now() + toIntMs(delayMs);
+    let handle;
+    const tick = () => {
+        const remaining = target - Date.now();
+        if (remaining <= 0) {
+            cb();
+            return;
+        }
+        handle = setTimeout(tick, Math.min(exports.MAX_DELAY_MS, remaining));
+    };
+    tick();
+    return {
+        clear() {
+            if (handle !== undefined) {
+                clearTimeout(handle);
+                handle = undefined;
+            }
+        },
+    };
+}
+function putTimer(map, key, controller) {
+    map[key]?.clear?.();
+    map[key] = controller;
+}
+function clearKey(map, key) {
+    map[key]?.clear?.();
+    delete map[key];
+}
+function clearAll(map) {
+    for (const k of Object.keys(map)) {
+        map[k]?.clear?.();
+        delete map[k];
+    }
+}
+function setCappedTimeoutInMap(map, key, cb, delayMs) {
+    putTimer(map, key, setCappedTimeout(cb, delayMs));
+}

package/dist/_esm/actions.js

@@ -0,0 +1,225 @@
+import { connect as wagmiConnect } from '@wagmi/core/actions';
+import { buildOAuthUrl, generateOAuthNonce, openOAuthPopup, pollOAuthPopup, } from './oauth.js';
+/**
+ * Get ZeroDev connector from config
+ */
+function getZeroDevConnector(config) {
+    const connector = config.connectors.find((c) => c.id === 'zerodev-wallet');
+    if (!connector) {
+        throw new Error('ZeroDev connector not found in Wagmi config');
+    }
+    return connector;
+}
+/**
+ * Register with passkey
+ */
+export async function registerPasskey(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');
+    await wallet.auth({
+        type: 'passkey',
+        email: parameters.email,
+        mode: 'register',
+    });
+    const [session, eoaAccount] = await Promise.all([
+        wallet.getSession(),
+        wallet.toAccount(),
+    ]);
+    store.getState().setEoaAccount(eoaAccount);
+    store.getState().setSession(session || null);
+    // Auto-connect to Wagmi
+    await wagmiConnect(config, { connector });
+}
+/**
+ * Login with passkey
+ */
+export async function loginPasskey(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');
+    await wallet.auth({
+        type: 'passkey',
+        email: parameters.email,
+        mode: 'login',
+    });
+    const [session, eoaAccount] = await Promise.all([
+        wallet.getSession(),
+        wallet.toAccount(),
+    ]);
+    store.getState().setEoaAccount(eoaAccount);
+    store.getState().setSession(session || null);
+    // Auto-connect to Wagmi
+    await wagmiConnect(config, { connector });
+}
+/**
+ * Authenticate with OAuth (opens popup)
+ */
+export async function authenticateOAuth(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;
+    const oauthConfig = store.getState().oauthConfig;
+    if (!wallet)
+        throw new Error('Wallet not initialized');
+    if (!oauthConfig) {
+        throw new Error('OAuth is not configured. Please provide oauthConfig to zeroDevWallet connector.');
+    }
+    // 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
+    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({
+        provider: parameters.provider,
+        clientId,
+        redirectUri: oauthConfig.redirectUri,
+        nonce,
+    });
+    // Open popup
+    const authWindow = openOAuthPopup(oauthUrl);
+    if (!authWindow) {
+        throw new Error(`Failed to open ${parameters.provider} login window.`);
+    }
+    // Poll for OAuth completion
+    return new Promise((resolve, reject) => {
+        pollOAuthPopup(authWindow, window.location.origin, async (idToken) => {
+            try {
+                // Complete OAuth authentication with wallet-core
+                await wallet.auth({
+                    type: 'oauth',
+                    provider: parameters.provider,
+                    credential: idToken,
+                });
+                const [session, eoaAccount] = await Promise.all([
+                    wallet.getSession(),
+                    wallet.toAccount(),
+                ]);
+                store.getState().setEoaAccount(eoaAccount);
+                store.getState().setSession(session || null);
+                // Auto-connect to Wagmi
+                await wagmiConnect(config, { connector });
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        }, reject);
+    });
+}
+/**
+ * Send OTP via email
+ */
+export async function sendOTP(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 result = await wallet.auth({
+        type: 'otp',
+        mode: 'sendOtp',
+        email: parameters.email,
+        contact: { type: 'email', contact: parameters.email },
+        ...(parameters.emailCustomization && {
+            emailCustomization: parameters.emailCustomization,
+        }),
+    });
+    return {
+        otpId: result.otpId,
+        subOrganizationId: result.subOrganizationId,
+    };
+}
+/**
+ * Verify OTP code
+ */
+export async function verifyOTP(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');
+    await wallet.auth({
+        type: 'otp',
+        mode: 'verifyOtp',
+        otpId: parameters.otpId,
+        otpCode: parameters.code,
+        subOrganizationId: parameters.subOrganizationId,
+    });
+    const [session, eoaAccount] = await Promise.all([
+        wallet.getSession(),
+        wallet.toAccount(),
+    ]);
+    store.getState().setEoaAccount(eoaAccount);
+    store.getState().setSession(session || null);
+    // Auto-connect to Wagmi
+    await wagmiConnect(config, { connector });
+}
+/**
+ * Refresh session
+ */
+export async function refreshSession(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;
+    const currentSession = store.getState().session;
+    if (!wallet || !currentSession) {
+        throw new Error('No active session to refresh');
+    }
+    const newSession = await wallet.refreshSession(currentSession.id);
+    store.getState().setSession(newSession || null);
+    return newSession;
+}
+/**
+ * Export wallet
+ */
+export async function exportWallet(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 { exportWallet: exportWalletSdk, createIframeStamper } = await import('@zerodev/wallet-core');
+    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-wallet-iframe',
+    });
+    const publicKey = await iframeStamper.init();
+    const { exportBundle, organizationId } = await exportWalletSdk({
+        wallet,
+        targetPublicKey: publicKey,
+    });
+    const success = await iframeStamper.injectWalletExportBundle(exportBundle, organizationId);
+    if (success !== true) {
+        throw new Error('Failed to inject export bundle');
+    }
+}