@openfort/react 0.3.1 → 1.0.0

package/build/wagmi/defaultConnectors.js

@@ -0,0 +1,36 @@
+import { safe, coinbaseWallet, walletConnect } from '@wagmi/connectors';
+import { embeddedWalletConnector } from './embeddedConnector.js';
+
+const defaultConnectors = ({ app, walletConnectProjectId, coinbaseWalletPreference, }) => {
+    const hasAllAppData = app.name && app.icon && app.description && app.url;
+    const shouldUseSafeConnector = !(typeof window === 'undefined') && (window === null || window === void 0 ? void 0 : window.parent) !== window;
+    const connectors = [embeddedWalletConnector()];
+    if (shouldUseSafeConnector) {
+        connectors.push(safe({
+            allowedDomains: [/gnosis-safe.io$/, /app.safe.global$/],
+        }));
+    }
+    connectors.push(coinbaseWallet({
+        appName: app.name,
+        appLogoUrl: app.icon,
+        overrideIsMetaMask: false,
+        preference: coinbaseWalletPreference,
+    }));
+    if (walletConnectProjectId) {
+        connectors.push(walletConnect({
+            projectId: walletConnectProjectId,
+            metadata: hasAllAppData
+                ? {
+                    name: app.name,
+                    description: app.description,
+                    url: app.url,
+                    icons: [app.icon],
+                }
+                : undefined,
+        }));
+    }
+    return connectors;
+};
+
+export { defaultConnectors as default };
+//# sourceMappingURL=defaultConnectors.js.map

package/build/wagmi/defaultConnectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConnectors.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/embeddedConnector.d.ts

@@ -0,0 +1,4 @@
+import { type CreateConnectorFn } from 'wagmi';
+import type { OpenfortEmbeddedEthereumWalletProvider } from '../ethereum/types';
+export declare function setEmbeddedWalletProvider(p: OpenfortEmbeddedEthereumWalletProvider | null): void;
+export declare function embeddedWalletConnector(): CreateConnectorFn<OpenfortEmbeddedEthereumWalletProvider | undefined>;

package/build/wagmi/embeddedConnector.js

@@ -0,0 +1,80 @@
+import { createConnector } from 'wagmi';
+import { embeddedWalletId } from '../constants/openfort.js';
+
+// Module-level provider store — injected when embedded wallet becomes active
+let _provider = null;
+function setEmbeddedWalletProvider(p) {
+    _provider = p;
+}
+function embeddedWalletConnector() {
+    return createConnector((config) => {
+        const accountsChangedHandler = (accs) => {
+            config.emitter.emit('change', { accounts: accs });
+        };
+        const chainChangedHandler = (chain) => {
+            config.emitter.emit('change', { chainId: Number(chain) });
+        };
+        const disconnectHandler = () => {
+            config.emitter.emit('disconnect');
+        };
+        return {
+            id: embeddedWalletId,
+            name: 'Openfort Embedded Wallet',
+            type: 'openfort-embedded',
+            async connect({ chainId, } = {}) {
+                const provider = _provider;
+                if (!provider)
+                    throw new Error('Embedded wallet provider not ready');
+                const accounts = (await provider.request({ method: 'eth_requestAccounts' }));
+                const currentChainId = await this.getChainId();
+                provider.on('accountsChanged', accountsChangedHandler);
+                provider.on('chainChanged', chainChangedHandler);
+                provider.on('disconnect', disconnectHandler);
+                return {
+                    accounts: accounts,
+                    chainId: chainId !== null && chainId !== void 0 ? chainId : currentChainId,
+                };
+            },
+            async disconnect() {
+                var _a, _b, _c;
+                // Auth lifecycle owned by Openfort, not wagmi — no-op
+                (_a = _provider === null || _provider === void 0 ? void 0 : _provider.removeListener) === null || _a === void 0 ? void 0 : _a.call(_provider, 'accountsChanged', accountsChangedHandler);
+                (_b = _provider === null || _provider === void 0 ? void 0 : _provider.removeListener) === null || _b === void 0 ? void 0 : _b.call(_provider, 'chainChanged', chainChangedHandler);
+                (_c = _provider === null || _provider === void 0 ? void 0 : _provider.removeListener) === null || _c === void 0 ? void 0 : _c.call(_provider, 'disconnect', disconnectHandler);
+            },
+            async getAccounts() {
+                if (!_provider)
+                    return [];
+                return (await _provider.request({ method: 'eth_accounts' }));
+            },
+            async getChainId() {
+                var _a, _b;
+                if (!_provider)
+                    return (_b = (_a = config.chains[0]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 1;
+                const hex = await _provider.request({ method: 'eth_chainId' });
+                return Number(hex);
+            },
+            async getProvider() {
+                return _provider !== null && _provider !== void 0 ? _provider : undefined;
+            },
+            async isAuthorized() {
+                if (!_provider)
+                    return false;
+                const accounts = (await _provider.request({ method: 'eth_accounts' }));
+                return accounts.length > 0;
+            },
+            onAccountsChanged(accounts) {
+                config.emitter.emit('change', { accounts: accounts });
+            },
+            onChainChanged(chain) {
+                config.emitter.emit('change', { chainId: Number(chain) });
+            },
+            onDisconnect() {
+                config.emitter.emit('disconnect');
+            },
+        };
+    });
+}
+
+export { embeddedWalletConnector, setEmbeddedWalletProvider };
+//# sourceMappingURL=embeddedConnector.js.map

package/build/wagmi/embeddedConnector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddedConnector.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/index.d.ts

@@ -0,0 +1,10 @@
+export { default as getDefaultConfig } from './defaultConfig';
+export { default as getDefaultConnectors, default as wallets, } from './defaultConnectors';
+export { embeddedWalletConnector, setEmbeddedWalletProvider } from './embeddedConnector';
+export { OpenfortWagmiBridge } from './OpenfortWagmiBridge';
+export { useChainIsSupported } from './useChainIsSupported';
+export { useChains } from './useChains';
+export { useConnectWithSiwe } from './useConnectWithSiwe';
+export { EmbeddedWalletWagmiSync } from './useEmbeddedWalletWagmiSync';
+export type { AvailableWallet } from './useWalletAuth';
+export { useWalletAuth } from './useWalletAuth';

package/build/wagmi/index.js

@@ -0,0 +1,10 @@
+export { default as getDefaultConfig } from './defaultConfig.js';
+export { default as getDefaultConnectors, default as wallets } from './defaultConnectors.js';
+export { embeddedWalletConnector, setEmbeddedWalletProvider } from './embeddedConnector.js';
+export { OpenfortWagmiBridge } from './OpenfortWagmiBridge.js';
+export { useChainIsSupported } from './useChainIsSupported.js';
+export { useChains } from './useChains.js';
+export { useConnectWithSiwe } from './useConnectWithSiwe.js';
+export { EmbeddedWalletWagmiSync } from './useEmbeddedWalletWagmiSync.js';
+export { useWalletAuth } from './useWalletAuth.js';
+//# sourceMappingURL=index.js.map

package/build/wagmi/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/build/wagmi/useChainIsSupported.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Check if a chain ID is supported in the current Wagmi configuration.
+ *
+ * Use this hook from `@openfort/react/wagmi` when your app uses WagmiProvider.
+ *
+ * @param chainId - The blockchain chain ID to check.
+ * @returns `true` when the chain is configured, `false` otherwise.
+ *
+ * @example
+ * ```tsx
+ * import { useChainIsSupported } from '@openfort/react/wagmi'
+ *
+ * function ChainStatus({ chainId }: { chainId?: number }) {
+ *   const isSupported = useChainIsSupported(chainId)
+ *
+ *   return <span>{isSupported ? 'Supported' : 'Unsupported'}</span>
+ * }
+ * ```
+ */
+export declare function useChainIsSupported(chainId?: number): boolean;

package/build/wagmi/useChainIsSupported.js

@@ -0,0 +1,30 @@
+import { useConfig } from 'wagmi';
+
+/**
+ * Check if a chain ID is supported in the current Wagmi configuration.
+ *
+ * Use this hook from `@openfort/react/wagmi` when your app uses WagmiProvider.
+ *
+ * @param chainId - The blockchain chain ID to check.
+ * @returns `true` when the chain is configured, `false` otherwise.
+ *
+ * @example
+ * ```tsx
+ * import { useChainIsSupported } from '@openfort/react/wagmi'
+ *
+ * function ChainStatus({ chainId }: { chainId?: number }) {
+ *   const isSupported = useChainIsSupported(chainId)
+ *
+ *   return <span>{isSupported ? 'Supported' : 'Unsupported'}</span>
+ * }
+ * ```
+ */
+function useChainIsSupported(chainId) {
+    const { chains } = useConfig();
+    if (chainId === undefined || chainId === null)
+        return false;
+    return chains.some((x) => x.id === chainId);
+}
+
+export { useChainIsSupported };
+//# sourceMappingURL=useChainIsSupported.js.map

package/build/wagmi/useChainIsSupported.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChainIsSupported.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/useChains.d.ts

@@ -0,0 +1,29 @@
+import type { Chain } from 'viem';
+/**
+ * Access all blockchain chains configured in the Wagmi config.
+ *
+ * Use this hook from `@openfort/react/wagmi` when your app uses WagmiProvider.
+ * Returns an array of chain objects (id, name, nativeCurrency, etc.).
+ *
+ * @returns Array of configured blockchain chains
+ *
+ * @example
+ * ```tsx
+ * import { useChains } from '@openfort/react/wagmi'
+ *
+ * function ChainSelector() {
+ *   const chains = useChains()
+ *
+ *   return (
+ *     <select>
+ *       {chains.map((chain) => (
+ *         <option key={chain.id} value={chain.id}>
+ *           {chain.name}
+ *         </option>
+ *       ))}
+ *     </select>
+ *   )
+ * }
+ * ```
+ */
+export declare function useChains(): Chain[];

package/build/wagmi/useChains.js

@@ -0,0 +1,38 @@
+import { useConfig } from 'wagmi';
+
+/**
+ * Access all blockchain chains configured in the Wagmi config.
+ *
+ * Use this hook from `@openfort/react/wagmi` when your app uses WagmiProvider.
+ * Returns an array of chain objects (id, name, nativeCurrency, etc.).
+ *
+ * @returns Array of configured blockchain chains
+ *
+ * @example
+ * ```tsx
+ * import { useChains } from '@openfort/react/wagmi'
+ *
+ * function ChainSelector() {
+ *   const chains = useChains()
+ *
+ *   return (
+ *     <select>
+ *       {chains.map((chain) => (
+ *         <option key={chain.id} value={chain.id}>
+ *           {chain.name}
+ *         </option>
+ *       ))}
+ *     </select>
+ *   )
+ * }
+ * ```
+ */
+function useChains() {
+    var _a;
+    const wagmi = useConfig();
+    const chains = (_a = wagmi === null || wagmi === void 0 ? void 0 : wagmi.chains) !== null && _a !== void 0 ? _a : [];
+    return chains.map((c) => c);
+}
+
+export { useChains };
+//# sourceMappingURL=useChains.js.map

package/build/wagmi/useChains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChains.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/useConnectWithSiwe.d.ts

@@ -0,0 +1,22 @@
+import { OpenfortError } from '@openfort/openfort-js';
+/**
+ * Returns connectWithSiwe for linking external wallets via SIWE.
+ *
+ * @returns { connectWithSiwe }
+ *
+ * @example
+ * ```tsx
+ * const { connectWithSiwe } = useConnectWithSiwe()
+ * await connectWithSiwe({ onConnect: () => router.replace('/dashboard') })
+ * ```
+ */
+export declare function useConnectWithSiwe(): {
+    connectWithSiwe: ({ onError, onConnect, address: propsAddress, connectorType: propsConnectorType, walletClientType: propsWalletClientType, link, }?: {
+        address?: `0x${string}`;
+        connectorType?: string;
+        walletClientType?: string;
+        onError?: (error: string, openfortError?: OpenfortError) => void;
+        onConnect?: () => void;
+        link?: boolean;
+    }) => Promise<void>;
+};

package/build/wagmi/useConnectWithSiwe.js

@@ -0,0 +1,115 @@
+import { OpenfortError } from '@openfort/openfort-js';
+import { useCallback } from 'react';
+import { useEthereumBridge } from '../ethereum/OpenfortEthereumBridgeContext.js';
+import { useOpenfortCore } from '../openfort/useOpenfort.js';
+import { createSIWEMessage } from '../siwe/create-siwe-message.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Returns connectWithSiwe for linking external wallets via SIWE.
+ *
+ * @returns { connectWithSiwe }
+ *
+ * @example
+ * ```tsx
+ * const { connectWithSiwe } = useConnectWithSiwe()
+ * await connectWithSiwe({ onConnect: () => router.replace('/dashboard') })
+ * ```
+ */
+function useConnectWithSiwe() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const { client, user, updateUser } = useOpenfortCore();
+    const bridge = useEthereumBridge();
+    const address = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _a === void 0 ? void 0 : _a.address;
+    const connector = (_b = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _b === void 0 ? void 0 : _b.connector;
+    const chainId = (_c = bridge === null || bridge === void 0 ? void 0 : bridge.chainId) !== null && _c !== void 0 ? _c : 0;
+    const accountChainId = (_f = (_e = (_d = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _d === void 0 ? void 0 : _d.chain) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : bridge === null || bridge === void 0 ? void 0 : bridge.chainId;
+    const chainName = (_h = (_g = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _g === void 0 ? void 0 : _g.chain) === null || _h === void 0 ? void 0 : _h.name;
+    const switchChainAsync = (_j = bridge === null || bridge === void 0 ? void 0 : bridge.switchChain) === null || _j === void 0 ? void 0 : _j.switchChainAsync;
+    const signMessage = bridge === null || bridge === void 0 ? void 0 : bridge.signMessage;
+    const connectWithSiwe = useCallback(async ({ onError, onConnect, address: propsAddress, connectorType: propsConnectorType, walletClientType: propsWalletClientType, link = !!user, } = {}) => {
+        var _a, _b;
+        const addressToUse = propsAddress !== null && propsAddress !== void 0 ? propsAddress : address;
+        const connectorType = propsConnectorType !== null && propsConnectorType !== void 0 ? propsConnectorType : connector === null || connector === void 0 ? void 0 : connector.type;
+        const walletClientType = propsWalletClientType !== null && propsWalletClientType !== void 0 ? propsWalletClientType : connector === null || connector === void 0 ? void 0 : connector.id;
+        if (!addressToUse || !connectorType || !walletClientType) {
+            logger.log('No address found', { address: addressToUse, connectorType, walletClientType });
+            onError === null || onError === void 0 ? void 0 : onError('No address found');
+            return;
+        }
+        if (!signMessage) {
+            onError === null || onError === void 0 ? void 0 : onError('EVM bridge not available (signMessage)');
+            return;
+        }
+        try {
+            if (accountChainId !== chainId && switchChainAsync) {
+                await switchChainAsync({ chainId });
+            }
+            let nonce;
+            if (link) {
+                const resp = await client.auth.initLinkSiwe({ address: addressToUse });
+                nonce = resp.nonce;
+            }
+            else {
+                const resp = await client.auth.initSiwe({ address: addressToUse });
+                nonce = resp.nonce;
+            }
+            const SIWEMessage = createSIWEMessage(addressToUse, nonce, chainId);
+            if (!SIWEMessage)
+                throw new Error('SIWE message creation failed (window not available)');
+            const signature = await signMessage({ message: SIWEMessage });
+            if (link) {
+                logger.log('Linking wallet to user');
+                await client.auth.linkWithSiwe({
+                    signature,
+                    message: SIWEMessage,
+                    connectorType,
+                    walletClientType,
+                    address: addressToUse,
+                    chainId,
+                });
+            }
+            else {
+                logger.log('Authenticating with SIWE');
+                await client.auth.loginWithSiwe({
+                    signature,
+                    message: SIWEMessage,
+                    connectorType,
+                    walletClientType,
+                    address: addressToUse,
+                });
+            }
+            await updateUser();
+            await Promise.resolve(onConnect === null || onConnect === void 0 ? void 0 : onConnect());
+        }
+        catch (err) {
+            logger.log('Failed to connect with SIWE', {
+                error: err,
+                status: (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'unknown',
+            });
+            if (!onError)
+                return;
+            let message = err instanceof Error ? err.message : String(err);
+            if (message.includes('User rejected the request.')) {
+                message = 'User rejected the request.';
+            }
+            else if (message.includes('Invalid signature')) {
+                message = 'Invalid signature. Please try again.';
+            }
+            else if (message.includes('An error occurred when attempting to switch chain')) {
+                message = `Failed to switch chain. Please switch your wallet to ${chainName !== null && chainName !== void 0 ? chainName : 'the correct network'} and try again.`;
+            }
+            else if (message.includes('already linked')) {
+                message = 'This wallet is already linked to another account. Log out and connect with this wallet instead.';
+            }
+            else {
+                message = 'Failed to connect with SIWE.';
+            }
+            onError(message, err instanceof OpenfortError ? err : undefined);
+        }
+    }, [client, user, updateUser, address, chainId, connector, accountChainId, chainName, switchChainAsync, signMessage]);
+    return { connectWithSiwe };
+}
+
+export { useConnectWithSiwe };
+//# sourceMappingURL=useConnectWithSiwe.js.map

package/build/wagmi/useConnectWithSiwe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConnectWithSiwe.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/useEmbeddedWalletWagmiSync.d.ts

@@ -0,0 +1,2 @@
+/** Null component — rendered inside CoreOpenfortProvider + WagmiProvider to sync embedded wallet into wagmi. */
+export declare function EmbeddedWalletWagmiSync(): null;

package/build/wagmi/useEmbeddedWalletWagmiSync.js

@@ -0,0 +1,55 @@
+import { useEffect } from 'react';
+import { useAccount, useConnect, useDisconnect } from 'wagmi';
+import { embeddedWalletId } from '../constants/openfort.js';
+import { useEthereumEmbeddedWallet } from '../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { setEmbeddedWalletProvider } from './embeddedConnector.js';
+
+/** Null component — rendered inside CoreOpenfortProvider + WagmiProvider to sync embedded wallet into wagmi. */
+function EmbeddedWalletWagmiSync() {
+    useEmbeddedWalletWagmiSync();
+    return null;
+}
+function useEmbeddedWalletWagmiSync() {
+    const wallet = useEthereumEmbeddedWallet();
+    const { connector: activeConnector, status: wagmiStatus } = useAccount();
+    const { connectAsync, connectors } = useConnect();
+    const { disconnectAsync } = useDisconnect();
+    const status = wallet.status;
+    const provider = status === 'connected' ? wallet.provider : null;
+    // Keep the module-level provider slot in sync — clear on disconnect
+    useEffect(() => {
+        if (status === 'connected' && provider) {
+            setEmbeddedWalletProvider(provider);
+            return () => {
+                setEmbeddedWalletProvider(null);
+            };
+        }
+    }, [status, provider]);
+    // Connect wagmi once the embedded wallet is ready AND wagmi has settled (not mid-reconnect)
+    useEffect(() => {
+        if (status !== 'connected' || !provider)
+            return;
+        if (wagmiStatus === 'connecting' || wagmiStatus === 'reconnecting')
+            return;
+        if ((activeConnector === null || activeConnector === void 0 ? void 0 : activeConnector.id) === embeddedWalletId)
+            return;
+        const embeddedConnector = connectors.find((c) => c.id === embeddedWalletId);
+        if (!embeddedConnector)
+            return;
+        connectAsync({ connector: embeddedConnector }).catch(() => { });
+    }, [status, provider, wagmiStatus, activeConnector, connectors, connectAsync]);
+    // Disconnect embedded connector from wagmi when the embedded wallet logs out
+    useEffect(() => {
+        if (status !== 'disconnected')
+            return;
+        if ((activeConnector === null || activeConnector === void 0 ? void 0 : activeConnector.id) !== embeddedWalletId)
+            return;
+        const embeddedConnector = connectors.find((c) => c.id === embeddedWalletId);
+        if (embeddedConnector) {
+            disconnectAsync({ connector: embeddedConnector }).catch(() => { });
+        }
+    }, [status, activeConnector, connectors, disconnectAsync]);
+}
+
+export { EmbeddedWalletWagmiSync };
+//# sourceMappingURL=useEmbeddedWalletWagmiSync.js.map

package/build/wagmi/useEmbeddedWalletWagmiSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmbeddedWalletWagmiSync.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wagmi/useWalletAuth.d.ts

@@ -0,0 +1,24 @@
+import { OpenfortError } from '../core/errors';
+import { type OpenfortEthereumBridgeConnector } from '../ethereum/OpenfortEthereumBridgeContext';
+import type { OpenfortHookOptions } from '../types';
+export interface AvailableWallet {
+    id: string;
+    name: string;
+    icon?: string;
+    connector: OpenfortEthereumBridgeConnector;
+}
+interface WalletAuthCallbacks {
+    onConnect?: () => void;
+    onError?: (error: string, openfortError?: OpenfortError) => void;
+}
+export declare function useWalletAuth(hookOptions?: OpenfortHookOptions): {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+    availableWallets: AvailableWallet[];
+    connectWallet: (connectorId: string, callbacks?: WalletAuthCallbacks) => Promise<void>;
+    linkWallet: (connectorId: string, callbacks?: WalletAuthCallbacks) => Promise<void>;
+    walletConnectingTo: string | null;
+};
+export {};