@tomo-inc/wallet-connect-protocol 0.0.4 → 0.0.6

package/dist/index.d.cts

@@ -0,0 +1,169 @@
+import { W as WalletConnectClient, S as SessionInfo, Q as QRCodeOptions, a as WalletConnectConfig, b as SiweConfig } from './vanilla-2_OWCFEZ.cjs';
+export { Z as APTOS_CHAINS, R as APTOS_NAMESPACE, t as AuthMethod, A as AuthOptions, T as COSMOS_NAMESPACE, u as ChainType, C as ConnectParams, M as EIP155_NAMESPACE, X as EVM_CHAINS, E as EventHandler, V as NEAR_NAMESPACE, N as NamespaceConfig, U as POLKADOT_NAMESPACE, P as POPULAR_WALLET_IDS, Y as SOLANA_CHAINS, O as SOLANA_NAMESPACE, a8 as SiweAuth, a1 as SiweResult, k as Wallet, l as WalletApp, r as WalletConnectEvent, m as WalletImage, n as WalletListOptions, o as WalletListResponse, p as WalletMetadata, q as WalletPlatform, I as copyToClipboard, $ as createMultiChainNamespaces, a7 as createSiweConfigFromSession, a2 as createSiweMessage, y as extractAddressFromAccount, z as extractChainIdFromAccount, a6 as extractChainIdNumber, x as formatAddress, J as formatError, F as formatTimestamp, H as generateDeepLink, a5 as generateNonce, g as getAllWallets, c as getBrowserWallets, _ as getChainName, a0 as getChainType, d as getDesktopWallets, e as getMobileWallets, f as getRecommendedWallets, D as getSessionTimeRemaining, h as getWalletById, i as getWalletConnectWallets, j as getWalletsByChain, G as isMobile, B as isSessionExpired, K as isValidChainId, v as isValidWalletConnectUri, L as parseChainId, a3 as parseSiweMessage, w as parseWalletConnectUri, s as searchWallets, a4 as verifySiweSignature } from './vanilla-2_OWCFEZ.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * WalletConnect Context type
+ */
+interface WalletConnectContextType {
+    /** client instance */
+    client: WalletConnectClient | null;
+    /** whether initialized */
+    initialized: boolean;
+    /** whether connecting */
+    connecting: boolean;
+    /** current URI */
+    uri: string | null;
+    /** active sessions list */
+    sessions: SessionInfo[];
+    /** initialize client */
+    initialize: () => Promise<void>;
+    /** create connection */
+    connect: () => Promise<string>;
+    /** generate QR code */
+    generateQRCode: (uri: string, options?: QRCodeOptions) => Promise<string>;
+    /** disconnect session */
+    disconnect: (topic: string) => Promise<void>;
+    /** refresh sessions list */
+    refreshSessions: () => void;
+}
+/**
+ * WalletConnect Provider Props
+ */
+interface WalletConnectProviderProps {
+    /** WalletConnect configuration */
+    config: WalletConnectConfig;
+    /** child components */
+    children: ReactNode;
+    /** whether to auto initialize */
+    autoInit?: boolean;
+}
+/**
+ * WalletConnect Provider Component
+ *
+ * @example
+ * ```tsx
+ * import { WalletConnectProvider } from '@tomo-inc/wallet-connect-protocol';
+ *
+ * function App() {
+ *   return (
+ *     <WalletConnectProvider
+ *       config={{
+ *         projectId: 'YOUR_PROJECT_ID',
+ *         metadata: {
+ *           name: 'My App',
+ *           description: 'My awesome dApp',
+ *           url: 'https://myapp.com',
+ *           icons: ['https://myapp.com/icon.png']
+ *         }
+ *       }}
+ *       autoInit
+ *     >
+ *       <YourApp />
+ *     </WalletConnectProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WalletConnectProvider({ config, children, autoInit }: WalletConnectProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to use WalletConnect Context
+ *
+ * @example
+ * ```tsx
+ * import { useWalletConnect } from '@tomo-inc/wallet-connect-protocol';
+ *
+ * function ConnectButton() {
+ *   const { connect, uri, generateQRCode } = useWalletConnect();
+ *   const [qrCode, setQrCode] = useState<string | null>(null);
+ *
+ *   const handleConnect = async () => {
+ *     const connectionUri = await connect();
+ *     const qr = await generateQRCode(connectionUri);
+ *     setQrCode(qr);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleConnect}>Connect Wallet</button>
+ *       {qrCode && <img src={qrCode} alt="WalletConnect QR Code" />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @throws if used outside WalletConnectProvider
+ */
+declare function useWalletConnect(): WalletConnectContextType;
+
+/**
+ * QR code generation Hook
+ * @param uri WalletConnect URI
+ * @param options QR code options
+ * @returns QR code data URL
+ */
+declare function useQRCode(uri?: string, options?: QRCodeOptions): {
+    qrCode: string | null;
+    loading: boolean;
+    error: Error | null;
+    generate: (targetUri?: string) => Promise<void>;
+};
+
+/**
+ * session management Hook
+ * @param topic optional session topic (if not provided, manage all sessions)
+ */
+declare function useSession(topic?: string): {
+    session: SessionInfo | null;
+    allSessions: SessionInfo[];
+    disconnect: (sessionTopic?: string) => Promise<void>;
+    refresh: () => void;
+    isExpired: boolean;
+    getAccounts: (session?: SessionInfo) => string[];
+    getChains: (session?: SessionInfo) => string[];
+    hasSession: boolean;
+};
+
+/**
+ * connection management Hook
+ * @param options configuration options
+ */
+declare function useConnect(options?: {
+    autoGenerateQRCode?: boolean;
+    qrCodeOptions?: QRCodeOptions;
+    onConnect?: (uri: string) => void;
+    onError?: (error: Error) => void;
+}): {
+    connect: () => Promise<string>;
+    uri: string | null;
+    qrCode: string | null;
+    connecting: boolean;
+    error: Error | null;
+    reset: () => void;
+};
+
+/**
+ * SIWE authentication Hook
+ */
+declare function useSiwe(config?: Partial<SiweConfig>): {
+    signIn: (sessionTopic?: string) => Promise<{
+        success: boolean;
+        address: string;
+        message: string;
+        signature: any;
+        siweMessage: any;
+    }>;
+    signOut: () => void;
+    isAuthenticating: boolean;
+    authResult: {
+        success: boolean;
+        address?: string;
+        message?: string;
+        signature?: string;
+        error?: string;
+    } | null;
+    isAuthenticated: boolean;
+};
+
+export { QRCodeOptions, SessionInfo, SiweConfig, WalletConnectClient, WalletConnectConfig, WalletConnectProvider, type WalletConnectProviderProps, useConnect, useQRCode, useSession, useSiwe, useWalletConnect };

package/dist/index.d.ts

@@ -0,0 +1,169 @@
+import { W as WalletConnectClient, S as SessionInfo, Q as QRCodeOptions, a as WalletConnectConfig, b as SiweConfig } from './vanilla-2_OWCFEZ.js';
+export { Z as APTOS_CHAINS, R as APTOS_NAMESPACE, t as AuthMethod, A as AuthOptions, T as COSMOS_NAMESPACE, u as ChainType, C as ConnectParams, M as EIP155_NAMESPACE, X as EVM_CHAINS, E as EventHandler, V as NEAR_NAMESPACE, N as NamespaceConfig, U as POLKADOT_NAMESPACE, P as POPULAR_WALLET_IDS, Y as SOLANA_CHAINS, O as SOLANA_NAMESPACE, a8 as SiweAuth, a1 as SiweResult, k as Wallet, l as WalletApp, r as WalletConnectEvent, m as WalletImage, n as WalletListOptions, o as WalletListResponse, p as WalletMetadata, q as WalletPlatform, I as copyToClipboard, $ as createMultiChainNamespaces, a7 as createSiweConfigFromSession, a2 as createSiweMessage, y as extractAddressFromAccount, z as extractChainIdFromAccount, a6 as extractChainIdNumber, x as formatAddress, J as formatError, F as formatTimestamp, H as generateDeepLink, a5 as generateNonce, g as getAllWallets, c as getBrowserWallets, _ as getChainName, a0 as getChainType, d as getDesktopWallets, e as getMobileWallets, f as getRecommendedWallets, D as getSessionTimeRemaining, h as getWalletById, i as getWalletConnectWallets, j as getWalletsByChain, G as isMobile, B as isSessionExpired, K as isValidChainId, v as isValidWalletConnectUri, L as parseChainId, a3 as parseSiweMessage, w as parseWalletConnectUri, s as searchWallets, a4 as verifySiweSignature } from './vanilla-2_OWCFEZ.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * WalletConnect Context type
+ */
+interface WalletConnectContextType {
+    /** client instance */
+    client: WalletConnectClient | null;
+    /** whether initialized */
+    initialized: boolean;
+    /** whether connecting */
+    connecting: boolean;
+    /** current URI */
+    uri: string | null;
+    /** active sessions list */
+    sessions: SessionInfo[];
+    /** initialize client */
+    initialize: () => Promise<void>;
+    /** create connection */
+    connect: () => Promise<string>;
+    /** generate QR code */
+    generateQRCode: (uri: string, options?: QRCodeOptions) => Promise<string>;
+    /** disconnect session */
+    disconnect: (topic: string) => Promise<void>;
+    /** refresh sessions list */
+    refreshSessions: () => void;
+}
+/**
+ * WalletConnect Provider Props
+ */
+interface WalletConnectProviderProps {
+    /** WalletConnect configuration */
+    config: WalletConnectConfig;
+    /** child components */
+    children: ReactNode;
+    /** whether to auto initialize */
+    autoInit?: boolean;
+}
+/**
+ * WalletConnect Provider Component
+ *
+ * @example
+ * ```tsx
+ * import { WalletConnectProvider } from '@tomo-inc/wallet-connect-protocol';
+ *
+ * function App() {
+ *   return (
+ *     <WalletConnectProvider
+ *       config={{
+ *         projectId: 'YOUR_PROJECT_ID',
+ *         metadata: {
+ *           name: 'My App',
+ *           description: 'My awesome dApp',
+ *           url: 'https://myapp.com',
+ *           icons: ['https://myapp.com/icon.png']
+ *         }
+ *       }}
+ *       autoInit
+ *     >
+ *       <YourApp />
+ *     </WalletConnectProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WalletConnectProvider({ config, children, autoInit }: WalletConnectProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to use WalletConnect Context
+ *
+ * @example
+ * ```tsx
+ * import { useWalletConnect } from '@tomo-inc/wallet-connect-protocol';
+ *
+ * function ConnectButton() {
+ *   const { connect, uri, generateQRCode } = useWalletConnect();
+ *   const [qrCode, setQrCode] = useState<string | null>(null);
+ *
+ *   const handleConnect = async () => {
+ *     const connectionUri = await connect();
+ *     const qr = await generateQRCode(connectionUri);
+ *     setQrCode(qr);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleConnect}>Connect Wallet</button>
+ *       {qrCode && <img src={qrCode} alt="WalletConnect QR Code" />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @throws if used outside WalletConnectProvider
+ */
+declare function useWalletConnect(): WalletConnectContextType;
+
+/**
+ * QR code generation Hook
+ * @param uri WalletConnect URI
+ * @param options QR code options
+ * @returns QR code data URL
+ */
+declare function useQRCode(uri?: string, options?: QRCodeOptions): {
+    qrCode: string | null;
+    loading: boolean;
+    error: Error | null;
+    generate: (targetUri?: string) => Promise<void>;
+};
+
+/**
+ * session management Hook
+ * @param topic optional session topic (if not provided, manage all sessions)
+ */
+declare function useSession(topic?: string): {
+    session: SessionInfo | null;
+    allSessions: SessionInfo[];
+    disconnect: (sessionTopic?: string) => Promise<void>;
+    refresh: () => void;
+    isExpired: boolean;
+    getAccounts: (session?: SessionInfo) => string[];
+    getChains: (session?: SessionInfo) => string[];
+    hasSession: boolean;
+};
+
+/**
+ * connection management Hook
+ * @param options configuration options
+ */
+declare function useConnect(options?: {
+    autoGenerateQRCode?: boolean;
+    qrCodeOptions?: QRCodeOptions;
+    onConnect?: (uri: string) => void;
+    onError?: (error: Error) => void;
+}): {
+    connect: () => Promise<string>;
+    uri: string | null;
+    qrCode: string | null;
+    connecting: boolean;
+    error: Error | null;
+    reset: () => void;
+};
+
+/**
+ * SIWE authentication Hook
+ */
+declare function useSiwe(config?: Partial<SiweConfig>): {
+    signIn: (sessionTopic?: string) => Promise<{
+        success: boolean;
+        address: string;
+        message: string;
+        signature: any;
+        siweMessage: any;
+    }>;
+    signOut: () => void;
+    isAuthenticating: boolean;
+    authResult: {
+        success: boolean;
+        address?: string;
+        message?: string;
+        signature?: string;
+        error?: string;
+    } | null;
+    isAuthenticated: boolean;
+};
+
+export { QRCodeOptions, SessionInfo, SiweConfig, WalletConnectClient, WalletConnectConfig, WalletConnectProvider, type WalletConnectProviderProps, useConnect, useQRCode, useSession, useSiwe, useWalletConnect };

package/dist/index.js

@@ -0,0 +1,349 @@
+import { WalletConnectClient, isSessionExpired, extractAddressFromAccount, extractChainIdFromAccount, extractChainIdNumber, createSiweConfigFromSession, SiweAuth } from './chunk-32KOSJUW.js';
+export { APTOS_CHAINS, APTOS_NAMESPACE, AuthMethod, COSMOS_NAMESPACE, ChainType, EIP155_NAMESPACE, EVM_CHAINS, NEAR_NAMESPACE, POLKADOT_NAMESPACE, POPULAR_WALLET_IDS, SOLANA_CHAINS, SOLANA_NAMESPACE, SiweAuth, WalletConnectClient, copyToClipboard, createMultiChainNamespaces, createSiweConfigFromSession, createSiweMessage, extractAddressFromAccount, extractChainIdFromAccount, extractChainIdNumber, formatAddress, formatError, formatTimestamp, generateDeepLink, generateNonce, getAllWallets, getBrowserWallets, getChainName, getChainType, getDesktopWallets, getMobileWallets, getRecommendedWallets, getSessionTimeRemaining, getWalletById, getWalletConnectWallets, getWalletsByChain, isMobile, isSessionExpired, isValidChainId, isValidWalletConnectUri, parseChainId, parseSiweMessage, parseWalletConnectUri, searchWallets, verifySiweSignature } from './chunk-32KOSJUW.js';
+import { createContext, useState, useCallback, useEffect, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var WalletConnectContext = createContext(void 0);
+function WalletConnectProvider({ config, children, autoInit = true }) {
+  const [client, setClient] = useState(null);
+  const [initialized, setInitialized] = useState(false);
+  const [connecting, setConnecting] = useState(false);
+  const [uri, setUri] = useState(null);
+  const [sessions, setSessions] = useState([]);
+  const refreshSessions = useCallback(() => {
+    if (client) {
+      const activeSessions = client.getActiveSessions();
+      setSessions(activeSessions);
+    }
+  }, [client]);
+  const initialize = useCallback(async () => {
+    if (initialized) {
+      return;
+    }
+    try {
+      const newClient = new WalletConnectClient(config);
+      newClient.on("display_uri", ({ uri: uri2 }) => {
+        setUri(uri2);
+      });
+      const handleSessionUpdate = () => {
+        const activeSessions2 = newClient.getActiveSessions();
+        setSessions(activeSessions2);
+      };
+      newClient.on("session_proposal", handleSessionUpdate);
+      newClient.on("session_update", handleSessionUpdate);
+      newClient.on("session_delete", handleSessionUpdate);
+      await newClient.initialize();
+      setClient(newClient);
+      setInitialized(true);
+      const activeSessions = newClient.getActiveSessions();
+      setSessions(activeSessions);
+    } catch (error) {
+      throw error;
+    }
+  }, [config, initialized]);
+  const connect = useCallback(async () => {
+    if (!client) {
+      throw new Error("WalletConnect client not initialized");
+    }
+    setConnecting(true);
+    try {
+      const connectionUri = await client.connect();
+      setUri(connectionUri);
+      return connectionUri;
+    } catch (error) {
+      throw error;
+    } finally {
+      setConnecting(false);
+    }
+  }, [client]);
+  const generateQRCode = useCallback(
+    async (uri2, options) => {
+      if (!client) {
+        throw new Error("WalletConnect client not initialized");
+      }
+      return client.generateQRCode(uri2, options);
+    },
+    [client]
+  );
+  const disconnect = useCallback(
+    async (topic) => {
+      if (!client) {
+        throw new Error("WalletConnect client not initialized");
+      }
+      await client.disconnectSession(topic);
+      refreshSessions();
+    },
+    [client]
+  );
+  useEffect(() => {
+    if (!client || !initialized) return;
+    const interval = setInterval(() => {
+      refreshSessions();
+    }, 2e3);
+    return () => clearInterval(interval);
+  }, [client, initialized, refreshSessions]);
+  useEffect(() => {
+    if (autoInit && !initialized) {
+      initialize().catch(console.error);
+    }
+  }, [autoInit, initialized, initialize]);
+  useEffect(() => {
+    return () => {
+      if (client) {
+        client.destroy().catch(console.error);
+      }
+    };
+  }, [client]);
+  const value = {
+    client,
+    initialized,
+    connecting,
+    uri,
+    sessions,
+    initialize,
+    connect,
+    generateQRCode,
+    disconnect,
+    refreshSessions
+  };
+  return /* @__PURE__ */ jsx(WalletConnectContext.Provider, { value, children });
+}
+function useWalletConnect() {
+  const context = useContext(WalletConnectContext);
+  if (!context) {
+    throw new Error("useWalletConnect must be used within WalletConnectProvider");
+  }
+  return context;
+}
+function useQRCode(uri, options) {
+  const { generateQRCode } = useWalletConnect();
+  const [qrCode, setQrCode] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const generate = useCallback(
+    async (targetUri) => {
+      const uriToUse = targetUri || uri;
+      if (!uriToUse) {
+        setError(new Error("No URI provided"));
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const qr = await generateQRCode(uriToUse, options);
+        setQrCode(qr);
+      } catch (err) {
+        setError(err);
+        setQrCode(null);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [uri, options, generateQRCode]
+  );
+  useEffect(() => {
+    if (uri) {
+      generate(uri);
+    }
+  }, [uri, generate]);
+  return {
+    qrCode,
+    loading,
+    error,
+    generate
+  };
+}
+function useSession(topic) {
+  const { sessions, disconnect, refreshSessions, client } = useWalletConnect();
+  const [currentSession, setCurrentSession] = useState(null);
+  useEffect(() => {
+    if (topic) {
+      const session = sessions.find((s) => s.topic === topic);
+      setCurrentSession(session || null);
+    } else {
+      setCurrentSession(sessions[0] || null);
+    }
+  }, [topic, sessions]);
+  const disconnectSession = useCallback(
+    async (sessionTopic) => {
+      const topicToDisconnect = sessionTopic || topic || currentSession?.topic;
+      if (!topicToDisconnect) {
+        throw new Error("No session to disconnect");
+      }
+      await disconnect(topicToDisconnect);
+    },
+    [topic, currentSession, disconnect]
+  );
+  const checkExpired = useCallback((session) => {
+    return isSessionExpired(session.expiry);
+  }, []);
+  const getAccounts = useCallback(
+    (session) => {
+      const targetSession = session || currentSession;
+      if (!targetSession) return [];
+      const allAccounts = [];
+      Object.values(targetSession.namespaces).forEach((namespace) => {
+        if (namespace.accounts) {
+          allAccounts.push(...namespace.accounts);
+        }
+      });
+      return allAccounts;
+    },
+    [currentSession]
+  );
+  const getChains = useCallback(
+    (session) => {
+      const targetSession = session || currentSession;
+      if (!targetSession) return [];
+      const allChains = [];
+      Object.values(targetSession.namespaces).forEach((namespace) => {
+        if (namespace.chains) {
+          allChains.push(...namespace.chains);
+        }
+      });
+      return allChains;
+    },
+    [currentSession]
+  );
+  return {
+    session: currentSession,
+    allSessions: sessions,
+    disconnect: disconnectSession,
+    refresh: refreshSessions,
+    isExpired: currentSession ? checkExpired(currentSession) : false,
+    getAccounts,
+    getChains,
+    hasSession: !!currentSession
+  };
+}
+function useConnect(options) {
+  const { connect, generateQRCode, connecting } = useWalletConnect();
+  const [uri, setUri] = useState(null);
+  const [qrCode, setQrCode] = useState(null);
+  const [error, setError] = useState(null);
+  const handleConnect = useCallback(async () => {
+    setError(null);
+    try {
+      const connectionUri = await connect();
+      setUri(connectionUri);
+      if (options?.onConnect) {
+        options.onConnect(connectionUri);
+      }
+      if (options?.autoGenerateQRCode !== false) {
+        const qr = await generateQRCode(connectionUri, options?.qrCodeOptions);
+        setQrCode(qr);
+      }
+      return connectionUri;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      options?.onError?.(error2);
+      throw error2;
+    }
+  }, [connect, generateQRCode, options]);
+  const reset = useCallback(() => {
+    setUri(null);
+    setQrCode(null);
+    setError(null);
+  }, []);
+  return {
+    connect: handleConnect,
+    uri,
+    qrCode,
+    connecting,
+    error,
+    reset
+  };
+}
+function useSiwe(config) {
+  const { client } = useWalletConnect();
+  const [isAuthenticating, setIsAuthenticating] = useState(false);
+  const [authResult, setAuthResult] = useState(null);
+  const signIn = useCallback(
+    async (sessionTopic) => {
+      if (!client) {
+        throw new Error("WalletConnect client not initialized");
+      }
+      const sessions = client.getActiveSessions();
+      if (sessions.length === 0) {
+        throw new Error("No active sessions. Connect wallet first.");
+      }
+      setIsAuthenticating(true);
+      setAuthResult(null);
+      try {
+        const session = sessionTopic ? sessions.find((s) => s.topic === sessionTopic) : sessions[0];
+        if (!session) {
+          throw new Error("Session not found");
+        }
+        const accounts = Object.values(session.namespaces).flatMap((ns) => ns.accounts || []);
+        const primaryAccount = accounts[0];
+        if (!primaryAccount) {
+          throw new Error("No accounts found in session");
+        }
+        const address = extractAddressFromAccount(primaryAccount);
+        const chainIdStr = extractChainIdFromAccount(primaryAccount);
+        const chainId = extractChainIdNumber(primaryAccount);
+        const siweConfig = createSiweConfigFromSession({
+          domain: config?.domain || window.location.host,
+          uri: config?.uri || window.location.origin,
+          chainId,
+          statement: config?.statement,
+          resources: config?.resources
+        });
+        const siweAuth = new SiweAuth(siweConfig);
+        const message = await siweAuth.createMessage(address);
+        if (!client.signClient) {
+          throw new Error("SignClient not initialized");
+        }
+        const signature = await client.signClient.request({
+          topic: session.topic,
+          chainId: chainIdStr,
+          request: {
+            method: "personal_sign",
+            params: [message, address]
+          }
+        });
+        const verifyResult = await siweAuth.verify(message, signature);
+        if (verifyResult.success) {
+          setAuthResult({
+            success: true,
+            address,
+            message,
+            signature
+          });
+          return {
+            success: true,
+            address,
+            message,
+            signature,
+            siweMessage: verifyResult.data
+          };
+        } else {
+          throw new Error(verifyResult.error || "Signature verification failed");
+        }
+      } catch (error) {
+        const errorMsg = error.message || "Authentication failed";
+        setAuthResult({
+          success: false,
+          error: errorMsg
+        });
+        throw error;
+      } finally {
+        setIsAuthenticating(false);
+      }
+    },
+    [client, config]
+  );
+  const signOut = useCallback(() => {
+    setAuthResult(null);
+  }, []);
+  return {
+    signIn,
+    signOut,
+    isAuthenticating,
+    authResult,
+    isAuthenticated: authResult?.success || false
+  };
+}
+
+export { WalletConnectProvider, useConnect, useQRCode, useSession, useSiwe, useWalletConnect };