@zerodev/wallet-react 0.0.1-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @zerodev/wallet-react
+
+## 0.0.1-alpha.0
+
+### Patch Changes
+
+- feat: @zerodev/wallet-react initial release
+- Updated dependencies
+  - @zerodev/wallet-core@0.0.1-alpha.4

package/dist/_cjs/actions.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPasskey = registerPasskey;
+exports.loginPasskey = loginPasskey;
+exports.authenticateOAuth = authenticateOAuth;
+exports.sendOTP = sendOTP;
+exports.verifyOTP = verifyOTP;
+exports.refreshSession = refreshSession;
+exports.exportWallet = exportWallet;
+const actions_1 = require("@wagmi/core/actions");
+const oauth_js_1 = require("./oauth.js");
+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;
+}
+async function registerPasskey(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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);
+    await (0, actions_1.connect)(config, { connector });
+}
+async function loginPasskey(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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);
+    await (0, actions_1.connect)(config, { connector });
+}
+async function authenticateOAuth(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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.');
+    }
+    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.');
+    }
+    const publicKey = await wallet.getPublicKey();
+    if (!publicKey) {
+        throw new Error('Failed to get wallet public key');
+    }
+    const nonce = (0, oauth_js_1.generateOAuthNonce)(publicKey);
+    const oauthUrl = (0, oauth_js_1.buildOAuthUrl)({
+        provider: parameters.provider,
+        clientId,
+        redirectUri: oauthConfig.redirectUri,
+        nonce,
+    });
+    const authWindow = (0, oauth_js_1.openOAuthPopup)(oauthUrl);
+    if (!authWindow) {
+        throw new Error(`Failed to open ${parameters.provider} login window.`);
+    }
+    return new Promise((resolve, reject) => {
+        (0, oauth_js_1.pollOAuthPopup)(authWindow, window.location.origin, async (idToken) => {
+            try {
+                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);
+                await (0, actions_1.connect)(config, { connector });
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        }, reject);
+    });
+}
+async function sendOTP(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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,
+    };
+}
+async function verifyOTP(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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);
+    await (0, actions_1.connect)(config, { connector });
+}
+async function refreshSession(config, parameters = {}) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    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;
+}
+async function exportWallet(config, parameters) {
+    const connector = parameters.connector ?? getZeroDevConnector(config);
+    const store = await connector.getStore();
+    const wallet = store.getState().wallet;
+    if (!wallet)
+        throw new Error('Wallet not initialized');
+    const { exportWallet: exportWalletSdk, createIframeStamper } = await Promise.resolve().then(() => require('@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');
+    }
+}

package/dist/_cjs/connector.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zeroDevWallet = zeroDevWallet;
+const core_1 = require("@wagmi/core");
+const sdk_1 = require("@zerodev/sdk");
+const constants_1 = require("@zerodev/sdk/constants");
+const wallet_core_1 = require("@zerodev/wallet-core");
+const viem_1 = require("viem");
+const provider_js_1 = require("./provider.js");
+const store_js_1 = require("./store.js");
+const aaUtils_js_1 = require("./utils/aaUtils.js");
+function zeroDevWallet(params) {
+    return (0, core_1.createConnector)((wagmiConfig) => {
+        let store;
+        let provider;
+        let initPromise;
+        const transports = wagmiConfig.transports;
+        const initialize = async () => {
+            initPromise ??= (async () => {
+                console.log('Initializing ZeroDevWallet connector...');
+                const wallet = await (0, wallet_core_1.createZeroDevWallet)({
+                    projectId: params.projectId,
+                    ...(params.organizationId && {
+                        organizationId: params.organizationId,
+                    }),
+                    ...(params.proxyBaseUrl && { proxyBaseUrl: params.proxyBaseUrl }),
+                    ...(params.sessionStorage && {
+                        sessionStorage: params.sessionStorage,
+                    }),
+                    ...(params.rpId && { rpId: params.rpId }),
+                });
+                store = (0, store_js_1.createZeroDevWalletStore)();
+                store.getState().setWallet(wallet);
+                const chainIds = params.chains.map((c) => c.id);
+                store.setState({ chainIds });
+                if (params.oauthConfig) {
+                    store.getState().setOAuthConfig(params.oauthConfig);
+                }
+                provider = (0, provider_js_1.createProvider)({
+                    store,
+                    config: params,
+                    chains: Array.from(params.chains),
+                });
+                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;
+        };
+        return {
+            id: 'zerodev-wallet',
+            name: 'ZeroDevWallet',
+            type: 'injected',
+            async setup() {
+                if (typeof window !== 'undefined') {
+                    await initialize();
+                }
+            },
+            async connect({ chainId, ...rest } = {}) {
+                const withCapabilities = ('withCapabilities' in rest && rest.withCapabilities) || false;
+                const isReconnecting = ('isReconnecting' in rest && rest.isReconnecting) || false;
+                await initialize();
+                console.log(isReconnecting
+                    ? 'Reconnecting ZeroDevWallet...'
+                    : 'Connecting ZeroDevWallet...');
+                const state = store.getState();
+                const activeChainId = chainId || state.chainIds[0];
+                if (!activeChainId) {
+                    throw new Error('No chain configured');
+                }
+                if (isReconnecting && state.kernelAccounts.has(activeChainId)) {
+                    const kernelAccount = state.kernelAccounts.get(activeChainId);
+                    if (kernelAccount?.address) {
+                        console.log('Already connected:', kernelAccount.address);
+                        return {
+                            accounts: [kernelAccount.address],
+                            chainId: activeChainId,
+                        };
+                    }
+                }
+                if (!state.eoaAccount) {
+                    throw new Error('Not authenticated. Please authenticate first using passkey, OAuth, or OTP.');
+                }
+                if (!state.kernelAccounts.has(activeChainId)) {
+                    const chain = params.chains.find((c) => c.id === activeChainId);
+                    if (!chain) {
+                        throw new Error(`Chain ${activeChainId} not found in config`);
+                    }
+                    const transport = transports?.[activeChainId] ?? (0, viem_1.http)();
+                    const publicClient = (0, viem_1.createPublicClient)({
+                        chain,
+                        transport,
+                    });
+                    console.log(`Creating kernel account for chain ${activeChainId}...`);
+                    const kernelAccount = await (0, sdk_1.createKernelAccount)(publicClient, {
+                        entryPoint: (0, constants_1.getEntryPoint)('0.7'),
+                        kernelVersion: constants_1.KERNEL_V3_3,
+                        eip7702Account: state.eoaAccount,
+                    });
+                    store.getState().setKernelAccount(activeChainId, kernelAccount);
+                    const kernelClient = (0, sdk_1.createKernelAccountClient)({
+                        account: kernelAccount,
+                        bundlerTransport: (0, viem_1.http)((0, aaUtils_js_1.getAAUrl)(activeChainId, params.aaUrl)),
+                        chain,
+                        client: publicClient,
+                        paymaster: (0, sdk_1.createZeroDevPaymasterClient)({
+                            chain,
+                            transport: (0, viem_1.http)((0, aaUtils_js_1.getAAUrl)(activeChainId, params.aaUrl)),
+                        }),
+                    });
+                    store.getState().setKernelClient(activeChainId, kernelClient);
+                }
+                store.getState().setActiveChain(activeChainId);
+                const freshState = store.getState();
+                const kernelAccount = freshState.kernelAccounts.get(activeChainId);
+                console.log('ZeroDevWallet connected:', kernelAccount.address);
+                const address = kernelAccount.address;
+                return {
+                    accounts: (withCapabilities
+                        ? [{ address, capabilities: {} }]
+                        : [address]),
+                    chainId: activeChainId,
+                };
+            },
+            async disconnect() {
+                console.log('Disconnecting ZeroDevWallet...');
+                if (!store)
+                    return;
+                const wallet = store.getState().wallet;
+                provider?.destroy();
+                await wallet?.logout();
+                store.getState().clear();
+            },
+            async getAccounts() {
+                if (!store)
+                    return [];
+                const { eoaAccount, kernelAccounts, chainIds } = store.getState();
+                if (eoaAccount) {
+                    return [eoaAccount.address];
+                }
+                const activeAccount = chainIds[0]
+                    ? kernelAccounts.get(chainIds[0])
+                    : null;
+                return activeAccount ? [activeAccount.address] : [];
+            },
+            async getChainId() {
+                if (!store)
+                    return params.chains[0].id;
+                return store.getState().chainIds[0] || params.chains[0].id;
+            },
+            async getProvider() {
+                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');
+                }
+                store.getState().setActiveChain(chainId);
+                if (!state.kernelAccounts.has(chainId)) {
+                    const chain = params.chains.find((c) => c.id === chainId);
+                    if (!chain) {
+                        throw new Error(`Chain ${chainId} not found in config`);
+                    }
+                    const transport = transports?.[chainId] ?? (0, viem_1.http)();
+                    const publicClient = (0, viem_1.createPublicClient)({
+                        chain,
+                        transport,
+                    });
+                    console.log(`Creating kernel account for chain ${chainId}...`);
+                    const kernelAccount = await (0, sdk_1.createKernelAccount)(publicClient, {
+                        entryPoint: (0, constants_1.getEntryPoint)('0.7'),
+                        kernelVersion: constants_1.KERNEL_V3_3,
+                        eip7702Account: state.eoaAccount,
+                    });
+                    store.getState().setKernelAccount(chainId, kernelAccount);
+                    const kernelClient = (0, sdk_1.createKernelAccountClient)({
+                        account: kernelAccount,
+                        bundlerTransport: (0, viem_1.http)((0, aaUtils_js_1.getAAUrl)(chainId, params.aaUrl)),
+                        chain,
+                        client: publicClient,
+                        paymaster: (0, sdk_1.createZeroDevPaymasterClient)({
+                            chain,
+                            transport: (0, viem_1.http)((0, aaUtils_js_1.getAAUrl)(chainId, params.aaUrl)),
+                        }),
+                    });
+                    store.getState().setKernelClient(chainId, kernelClient);
+                }
+                return params.chains.find((c) => c.id === chainId);
+            },
+            async isAuthorized() {
+                if (!store)
+                    return false;
+                return !!store.getState().eoaAccount;
+            },
+            async getStore() {
+                await initialize();
+                return store;
+            },
+            onAccountsChanged() {
+            },
+            onChainChanged() {
+            },
+            onConnect() {
+            },
+            onDisconnect() {
+                console.log('Disconnect event');
+                provider?.destroy();
+                store.getState().clear();
+            },
+        };
+    });
+}

package/dist/_cjs/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZERODEV_AA_URL = void 0;
+exports.ZERODEV_AA_URL = 'https://rpc.zerodev.app/api/v3/';

package/dist/_cjs/hooks/useAuthenticateOAuth.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthenticateOAuth = useAuthenticateOAuth;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useAuthenticateOAuth(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.authenticateOAuth)(config, variables);
+        },
+        mutationKey: ['authenticateOAuth'],
+    });
+}

package/dist/_cjs/hooks/useExportWallet.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExportWallet = useExportWallet;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useExportWallet(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.exportWallet)(config, variables);
+        },
+        mutationKey: ['exportWallet'],
+    });
+}

package/dist/_cjs/hooks/useLoginPasskey.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLoginPasskey = useLoginPasskey;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useLoginPasskey(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.loginPasskey)(config, variables);
+        },
+        mutationKey: ['loginPasskey'],
+    });
+}

package/dist/_cjs/hooks/useRefreshSession.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRefreshSession = useRefreshSession;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useRefreshSession(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.refreshSession)(config, variables);
+        },
+        mutationKey: ['refreshSession'],
+    });
+}

package/dist/_cjs/hooks/useRegisterPasskey.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRegisterPasskey = useRegisterPasskey;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useRegisterPasskey(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.registerPasskey)(config, variables);
+        },
+        mutationKey: ['registerPasskey'],
+    });
+}

package/dist/_cjs/hooks/useSendOTP.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSendOTP = useSendOTP;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useSendOTP(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.sendOTP)(config, variables);
+        },
+        mutationKey: ['sendOTP'],
+    });
+}

package/dist/_cjs/hooks/useVerifyOTP.js

@@ -0,0 +1,18 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVerifyOTP = useVerifyOTP;
+const react_query_1 = require("@tanstack/react-query");
+const wagmi_1 = require("wagmi");
+const actions_js_1 = require("../actions.js");
+function useVerifyOTP(parameters = {}) {
+    const { mutation } = parameters;
+    const config = (0, wagmi_1.useConfig)(parameters);
+    return (0, react_query_1.useMutation)({
+        ...mutation,
+        async mutationFn(variables) {
+            return (0, actions_js_1.verifyOTP)(config, variables);
+        },
+        mutationKey: ['verifyOTP'],
+    });
+}

package/dist/_cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZeroDevWalletStore = exports.OAUTH_PROVIDERS = exports.useVerifyOTP = exports.useSendOTP = exports.useRegisterPasskey = exports.useRefreshSession = exports.useLoginPasskey = exports.useExportWallet = exports.useAuthenticateOAuth = exports.zeroDevWallet = void 0;
+var connector_js_1 = require("./connector.js");
+Object.defineProperty(exports, "zeroDevWallet", { enumerable: true, get: function () { return connector_js_1.zeroDevWallet; } });
+var useAuthenticateOAuth_js_1 = require("./hooks/useAuthenticateOAuth.js");
+Object.defineProperty(exports, "useAuthenticateOAuth", { enumerable: true, get: function () { return useAuthenticateOAuth_js_1.useAuthenticateOAuth; } });
+var useExportWallet_js_1 = require("./hooks/useExportWallet.js");
+Object.defineProperty(exports, "useExportWallet", { enumerable: true, get: function () { return useExportWallet_js_1.useExportWallet; } });
+var useLoginPasskey_js_1 = require("./hooks/useLoginPasskey.js");
+Object.defineProperty(exports, "useLoginPasskey", { enumerable: true, get: function () { return useLoginPasskey_js_1.useLoginPasskey; } });
+var useRefreshSession_js_1 = require("./hooks/useRefreshSession.js");
+Object.defineProperty(exports, "useRefreshSession", { enumerable: true, get: function () { return useRefreshSession_js_1.useRefreshSession; } });
+var useRegisterPasskey_js_1 = require("./hooks/useRegisterPasskey.js");
+Object.defineProperty(exports, "useRegisterPasskey", { enumerable: true, get: function () { return useRegisterPasskey_js_1.useRegisterPasskey; } });
+var useSendOTP_js_1 = require("./hooks/useSendOTP.js");
+Object.defineProperty(exports, "useSendOTP", { enumerable: true, get: function () { return useSendOTP_js_1.useSendOTP; } });
+var useVerifyOTP_js_1 = require("./hooks/useVerifyOTP.js");
+Object.defineProperty(exports, "useVerifyOTP", { enumerable: true, get: function () { return useVerifyOTP_js_1.useVerifyOTP; } });
+var oauth_js_1 = require("./oauth.js");
+Object.defineProperty(exports, "OAUTH_PROVIDERS", { enumerable: true, get: function () { return oauth_js_1.OAUTH_PROVIDERS; } });
+var store_js_1 = require("./store.js");
+Object.defineProperty(exports, "createZeroDevWalletStore", { enumerable: true, get: function () { return store_js_1.createZeroDevWalletStore; } });

package/dist/_cjs/oauth.js

@@ -0,0 +1,84 @@
+"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;
+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;
+    const left = window.screenX + (window.innerWidth - width) / 2;
+    const top = window.screenY + (window.innerHeight - height) / 2;
+    const authWindow = window.open('about:blank', '_blank', `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+    if (authWindow) {
+        authWindow.location.href = 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');
+    }
+    return idToken;
+}
+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);
+                }
+            }
+        }
+        catch {
+        }
+    }, 500);
+}
+function generateOAuthNonce(publicKey) {
+    return (0, viem_1.sha256)(publicKey).replace(/^0x/, '');
+}

package/dist/_cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}