@silentswap/react 0.0.41

package/dist/hooks/silent/orderTrackingWebSocketManager.js

@@ -0,0 +1,284 @@
+/**
+ * Shared WebSocket connection manager for order tracking
+ * Maintains one connection per client/baseUrl and handles multiple order subscriptions
+ */
+class OrderTrackingWebSocketManager {
+    connections = new Map();
+    /**
+     * Get connection key from client
+     */
+    getConnectionKey(client) {
+        if (client) {
+            return client.baseUrl;
+        }
+        if (typeof window !== 'undefined') {
+            return window.location.origin;
+        }
+        return 'default';
+    }
+    /**
+     * Get WebSocket URL from client
+     */
+    getWebSocketUrl(client) {
+        let wsUrl;
+        if (typeof window !== 'undefined' && window.__WEBSOCKET_URL__) {
+            wsUrl = window.__WEBSOCKET_URL__;
+        }
+        else if (client) {
+            const baseUrl = client.baseUrl;
+            try {
+                const url = new URL(baseUrl);
+                const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+                wsUrl = `${protocol}//${url.host}/websocket`;
+            }
+            catch {
+                wsUrl = baseUrl.replace(/^https?:\/\//, 'wss://').replace(/^http:\/\//, 'ws://') + '/websocket';
+            }
+        }
+        else if (typeof window !== 'undefined') {
+            wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}/websocket`;
+        }
+        else {
+            wsUrl = 'ws://localhost/websocket';
+        }
+        // Ensure URL doesn't have any path or query params
+        try {
+            const url = new URL(wsUrl);
+            const protocol = url.protocol === 'https:' || url.protocol === 'wss:' ? 'wss:' : 'ws:';
+            wsUrl = `${protocol}//${url.host}/websocket`;
+        }
+        catch {
+            wsUrl = wsUrl.split('?')[0].split('#')[0].replace(/\/+$/, '') + '/websocket';
+        }
+        return wsUrl;
+    }
+    /**
+     * Get or create connection state
+     */
+    getConnectionState(client) {
+        const key = this.getConnectionKey(client);
+        let state = this.connections.get(key);
+        if (!state) {
+            state = {
+                ws: null,
+                url: this.getWebSocketUrl(client),
+                isConnected: false,
+                isConnecting: false,
+                subscriptions: new Map(),
+                requestHandlers: new Map(),
+                requestCounter: 0,
+                reconnectTimeout: null,
+                reconnectAttempts: 0,
+                reconnectDelay: 1000,
+                lastReceived: 0,
+                isReconnecting: false,
+                maxReconnectAttempts: 5,
+            };
+            this.connections.set(key, state);
+        }
+        return state;
+    }
+    /**
+     * Connect WebSocket if not already connected
+     */
+    connectWebSocket(state) {
+        if (state.ws && state.ws.readyState === WebSocket.OPEN) {
+            return; // Already connected
+        }
+        if (state.isConnecting || state.isReconnecting) {
+            return; // Already connecting
+        }
+        // Close existing connection if any
+        if (state.ws) {
+            state.ws.close();
+            state.ws = null;
+        }
+        state.isConnecting = true;
+        try {
+            const ws = new WebSocket(state.url);
+            state.ws = ws;
+            ws.onopen = () => {
+                state.lastReceived = Date.now();
+                state.isConnected = true;
+                state.isConnecting = false;
+                state.isReconnecting = false;
+                state.reconnectAttempts = 0;
+                state.reconnectDelay = 1000;
+                // Subscribe all existing subscriptions
+                state.subscriptions.forEach((handler) => {
+                    this.subscribeOrder(state, handler.orderId, handler.auth, handler);
+                });
+            };
+            ws.onmessage = (event) => {
+                state.lastReceived = Date.now();
+                try {
+                    const response = JSON.parse(event.data);
+                    if (response.jsonrpc !== '2.0' || typeof response.id !== 'number') {
+                        return;
+                    }
+                    const handler = state.requestHandlers.get(response.id);
+                    if (handler) {
+                        handler(response.error, response.result);
+                    }
+                }
+                catch (parseError) {
+                    console.warn('Failed to parse WebSocket message:', parseError);
+                }
+            };
+            ws.onerror = () => {
+                state.isConnecting = false;
+                // Error will be handled by onclose
+            };
+            ws.onclose = () => {
+                state.isConnected = false;
+                state.isConnecting = false;
+                state.requestHandlers.clear();
+                // Reconnect if we have active subscriptions
+                if (state.subscriptions.size > 0 && !state.isReconnecting) {
+                    this.scheduleReconnect(state);
+                }
+            };
+        }
+        catch (err) {
+            state.isConnecting = false;
+            console.error('Failed to create WebSocket connection:', err);
+        }
+    }
+    /**
+     * Schedule reconnection with exponential backoff
+     */
+    scheduleReconnect(state) {
+        if (state.reconnectAttempts >= state.maxReconnectAttempts) {
+            // Notify all subscriptions of error
+            const error = new Error(`WebSocket connection failed after ${state.maxReconnectAttempts} attempts`);
+            state.subscriptions.forEach((handler) => {
+                handler.onError(error);
+            });
+            // Reset after delay to allow retry later
+            state.reconnectTimeout = setTimeout(() => {
+                state.reconnectAttempts = 0;
+                state.reconnectDelay = 1000;
+            }, 30000);
+            return;
+        }
+        state.isReconnecting = true;
+        state.reconnectAttempts += 1;
+        const currentDelay = state.reconnectDelay;
+        state.reconnectDelay = Math.min(currentDelay * 2, 30000);
+        const timeSinceLastReceived = Date.now() - state.lastReceived;
+        const extraDelay = timeSinceLastReceived > 90000 ? 5000 : 0;
+        const totalDelay = currentDelay + extraDelay;
+        state.reconnectTimeout = setTimeout(() => {
+            if (state.subscriptions.size > 0) {
+                state.isReconnecting = false;
+                this.connectWebSocket(state);
+            }
+            else {
+                state.isReconnecting = false;
+                state.reconnectAttempts = 0;
+                state.reconnectDelay = 1000;
+            }
+        }, totalDelay);
+    }
+    /**
+     * Subscribe to an order
+     */
+    subscribeOrder(state, orderId, auth, handler) {
+        if (!state.ws || state.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const requestId = state.requestCounter++;
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'connect',
+            params: {
+                auth: {
+                    orderId,
+                    viewingAuth: auth,
+                },
+            },
+        };
+        // Set up handler for initial response and subsequent updates
+        // Note: The server sends multiple responses with the same request ID for status updates
+        state.requestHandlers.set(requestId, (error, result) => {
+            if (error) {
+                const err = new Error(error.message || 'Connection error');
+                handler.onError(err);
+                return;
+            }
+            // Check if this is an initial OrderStatus or a StatusUpdate
+            // OrderStatus has a 'deposit' field, StatusUpdate has a 'type' field
+            const data = result;
+            if ('type' in data) {
+                // This is a StatusUpdate
+                handler.onStatusChange(data);
+            }
+            else {
+                // This is an initial OrderStatus
+                handler.onStatusUpdate(data);
+                // Replace handler for subsequent status updates (reuse same request ID)
+                state.requestHandlers.set(requestId, (statusError, statusResult) => {
+                    if (statusError) {
+                        const err = new Error(statusError.message || 'Status error');
+                        handler.onError(err);
+                        return;
+                    }
+                    // Handle status update
+                    const update = statusResult;
+                    handler.onStatusChange(update);
+                });
+            }
+        });
+        state.ws.send(JSON.stringify(request));
+    }
+    /**
+     * Subscribe to order tracking
+     */
+    subscribe(client, orderId, auth, handlers) {
+        const state = this.getConnectionState(client);
+        const subscriptionKey = `${orderId}:${auth}`;
+        // Create subscription handler
+        const subscriptionHandler = {
+            orderId,
+            auth,
+            ...handlers,
+        };
+        // Add subscription
+        state.subscriptions.set(subscriptionKey, subscriptionHandler);
+        // Connect if not connected
+        if (!state.isConnected && !state.isConnecting) {
+            this.connectWebSocket(state);
+        }
+        else if (state.isConnected) {
+            // Already connected, subscribe immediately
+            this.subscribeOrder(state, orderId, auth, subscriptionHandler);
+        }
+        // Return unsubscribe function
+        return () => {
+            state.subscriptions.delete(subscriptionKey);
+            // If no more subscriptions, close connection
+            if (state.subscriptions.size === 0) {
+                if (state.reconnectTimeout) {
+                    clearTimeout(state.reconnectTimeout);
+                    state.reconnectTimeout = null;
+                }
+                if (state.ws) {
+                    state.ws.close();
+                    state.ws = null;
+                }
+                state.isConnected = false;
+                state.isReconnecting = false;
+            }
+        };
+    }
+    /**
+     * Get connection status
+     */
+    isConnected(client) {
+        const state = this.getConnectionState(client);
+        return state.isConnected;
+    }
+}
+// Singleton instance
+export const orderTrackingWebSocketManager = new OrderTrackingWebSocketManager();

package/dist/hooks/silent/solana-transaction.d.ts

@@ -0,0 +1,60 @@
+import type { BridgeTransaction } from '@silentswap/sdk';
+import type { SolanaTransactionExecutor } from '@silentswap/sdk';
+import { type Signature, type Blockhash } from '@solana/kit';
+import { createSolanaRpc } from '@solana/rpc';
+/**
+ * Solana wallet connector interface
+ * Compatible with @solana/wallet-adapter-react and other Solana wallet adapters
+ */
+export interface SolanaWalletConnector {
+    signTransaction: (transaction: any) => Promise<any>;
+    sendTransaction: (transaction: any, connection: any) => Promise<string>;
+    publicKey: {
+        toString: () => string;
+    } | null;
+}
+/**
+ * Solana connection interface
+ * Compatible with @solana/rpc RPC client
+ */
+export interface SolanaConnection {
+    getLatestBlockhash: (commitment?: string) => Promise<{
+        blockhash: Blockhash;
+        lastValidBlockHeight: bigint;
+    }>;
+    confirmTransaction: (config: {
+        signature: Signature;
+        blockhash: Blockhash;
+        lastValidBlockHeight: bigint;
+    }, commitment?: string) => Promise<{
+        value: {
+            err: any;
+        };
+    }>;
+    rpc?: ReturnType<typeof createSolanaRpc>;
+    connection?: any;
+}
+/**
+ * Create a Solana transaction executor
+ * This function creates a transaction executor that can handle Solana transactions
+ * from relay.link bridge quotes
+ *
+ * @param connector - Solana wallet connector (from @solana/wallet-adapter-react or similar)
+ * @param connection - Solana RPC connection (from @solana/rpc)
+ * @returns Solana transaction executor function
+ */
+export declare function createSolanaTransactionExecutor(connector: SolanaWalletConnector, connection: SolanaConnection): SolanaTransactionExecutor;
+/**
+ * Helper to convert relay.link Solana step data to BridgeTransaction
+ */
+export declare function convertRelaySolanaStepToTransaction(stepData: {
+    instructions: Array<{
+        programId: string;
+        keys: Array<{
+            pubkey: string;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+        data: string;
+    }>;
+}, feePayer: string, chainId: number): BridgeTransaction;

package/dist/hooks/silent/solana-transaction.js

@@ -0,0 +1,236 @@
+import { address, appendTransactionMessageInstructions, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, compileTransaction, getBase64EncodedWireTransaction, getTransactionDecoder, getCompiledTransactionMessageDecoder, decompileTransactionMessage, pipe, AccountRole, } from '@solana/kit';
+import { createSolanaRpc } from '@solana/rpc';
+import { VersionedTransaction } from '@solana/web3.js';
+/**
+ * Create a Solana transaction executor
+ * This function creates a transaction executor that can handle Solana transactions
+ * from relay.link bridge quotes
+ *
+ * @param connector - Solana wallet connector (from @solana/wallet-adapter-react or similar)
+ * @param connection - Solana RPC connection (from @solana/rpc)
+ * @returns Solana transaction executor function
+ */
+export function createSolanaTransactionExecutor(connector, connection) {
+    return async (tx) => {
+        try {
+            if (!connector.publicKey) {
+                throw new Error('Solana wallet not connected');
+            }
+            console.log('Creating Solana transaction:', {
+                hasData: !!tx.data,
+                hasInstructions: !!tx.instructions,
+                instructionsCount: tx.instructions?.length,
+                feePayer: tx.feePayer,
+                publicKey: connector.publicKey.toString(),
+            });
+            // Get RPC client from connection or create a default one
+            const rpc = connection.rpc || createSolanaRpc('https://api.mainnet-beta.solana.com');
+            let transactionMessage;
+            let blockhash;
+            let lastValidBlockHeight;
+            // Check if transaction has serialized data (from deBridge)
+            // deBridge returns Solana transactions as serialized hex strings in tx.data
+            if (tx.data && !tx.instructions && !tx.to) {
+                // Deserialize transaction from hex data
+                // Remove 0x prefix if present
+                const hexData = tx.data.replace(/^0x/, '');
+                const buffer = Buffer.from(hexData, 'hex');
+                // Decode transaction using @solana/kit
+                const decoded = getTransactionDecoder().decode(new Uint8Array(buffer));
+                // Extract blockhash from decoded transaction
+                const compiledMessage = getCompiledTransactionMessageDecoder().decode(decoded.messageBytes);
+                transactionMessage = decompileTransactionMessage(compiledMessage);
+                // Get blockhash from the decoded transaction's lifetime token
+                // In @solana/kit v5, lifetime is stored as lifetimeToken (blockhash string)
+                if ('lifetimeToken' in compiledMessage) {
+                    blockhash = compiledMessage.lifetimeToken;
+                    // For deserialized transactions, we don't have lastValidBlockHeight
+                    // We'll need to fetch it from RPC
+                    const blockhashResponse = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
+                    lastValidBlockHeight = blockhashResponse.value.lastValidBlockHeight;
+                }
+            }
+            else if (tx.instructions) {
+                // Transaction has instructions (from relay.link)
+                // Get fee payer from transaction or use connector's public key
+                const feePayer = tx.feePayer || connector.publicKey.toString();
+                const feePayerAddress = address(feePayer);
+                // Get latest blockhash using RPC
+                const blockhashResponse = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
+                const latestBlockhash = {
+                    blockhash: blockhashResponse.value.blockhash,
+                    lastValidBlockHeight: blockhashResponse.value.lastValidBlockHeight,
+                };
+                blockhash = latestBlockhash.blockhash;
+                lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+                console.log('Got blockhash:', {
+                    blockhash,
+                    lastValidBlockHeight: lastValidBlockHeight.toString(),
+                });
+                // Convert relay.link instructions to @solana/kit Instruction format
+                // @solana/kit expects: { programAddress, accounts, data }
+                // where accounts is array of { address, role: AccountRole }
+                console.log('Converting instructions:', tx.instructions.length);
+                const instructions = tx.instructions.map((inst, instIndex) => {
+                    try {
+                        // Log original values for debugging
+                        console.log(`Instruction ${instIndex}:`, {
+                            programId: inst.programId,
+                            programIdLength: inst.programId?.length,
+                            keysCount: inst.keys?.length,
+                        });
+                        // Validate and convert programId to base58 address
+                        if (!inst.programId || typeof inst.programId !== 'string') {
+                            throw new Error(`Invalid programId in instruction ${instIndex}: ${inst.programId}`);
+                        }
+                        const programIdAddress = address(inst.programId);
+                        // Validate and convert all pubkey addresses in keys
+                        // @solana/kit expects AccountMeta with { address, role: AccountRole }
+                        const accounts = inst.keys.map((key, keyIndex) => {
+                            console.log('Key:', key);
+                            if (!key.pubkey || typeof key.pubkey !== 'string') {
+                                throw new Error(`Invalid pubkey in instruction ${instIndex}, key ${keyIndex}: ${key.pubkey}`);
+                            }
+                            // Log original pubkey for debugging
+                            if (key.pubkey.length < 32 || key.pubkey.length > 44) {
+                                console.warn(`Suspicious pubkey length in instruction ${instIndex}, key ${keyIndex}:`, {
+                                    pubkey: key.pubkey,
+                                    length: key.pubkey.length,
+                                    isSigner: key.isSigner,
+                                    isWritable: key.isWritable,
+                                });
+                            }
+                            try {
+                                const validatedAddress = address(key.pubkey);
+                                // @solana/kit AccountRole enum:
+                                // WRITABLE_SIGNER = 3, READONLY_SIGNER = 2, WRITABLE = 1, READONLY = 0
+                                let role;
+                                if (key.isSigner && key.isWritable) {
+                                    role = AccountRole.WRITABLE_SIGNER;
+                                }
+                                else if (key.isSigner && !key.isWritable) {
+                                    role = AccountRole.READONLY_SIGNER;
+                                }
+                                else if (!key.isSigner && key.isWritable) {
+                                    role = AccountRole.WRITABLE;
+                                }
+                                else {
+                                    role = AccountRole.READONLY;
+                                }
+                                return {
+                                    address: validatedAddress,
+                                    role,
+                                };
+                            }
+                            catch (error) {
+                                throw new Error(`Failed to validate pubkey in instruction ${instIndex}, key ${keyIndex}: ${key.pubkey}. Error: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        });
+                        // Convert data to Uint8Array
+                        const instructionData = inst.data.startsWith('0x')
+                            ? new Uint8Array(Buffer.from(inst.data.slice(2), 'hex'))
+                            : new Uint8Array(Buffer.from(inst.data, 'hex'));
+                        // @solana/kit Instruction format: { programAddress, accounts, data }
+                        return {
+                            programAddress: programIdAddress,
+                            accounts,
+                            data: instructionData,
+                        };
+                    }
+                    catch (error) {
+                        console.error(`Error converting instruction ${instIndex}:`, {
+                            instruction: inst,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        throw error;
+                    }
+                });
+                // Build transaction message using pipe pattern (following @solana/kit best practices)
+                transactionMessage = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayer(feePayerAddress, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions(instructions, tx));
+                console.log('Transaction message built successfully');
+            }
+            else {
+                throw new Error('Solana transaction must have either instructions or serialized data');
+            }
+            // Compile transaction message to get wire format
+            console.log('Compiling transaction...');
+            const compiledTransaction = compileTransaction(transactionMessage);
+            // Convert to VersionedTransaction for wallet adapter signing
+            const base64WireTransaction = getBase64EncodedWireTransaction(compiledTransaction);
+            const transactionBytes = Buffer.from(base64WireTransaction, 'base64');
+            console.log('Transaction bytes length:', transactionBytes.length);
+            // Create VersionedTransaction from wire bytes
+            const versionedTransaction = VersionedTransaction.deserialize(transactionBytes);
+            console.log('Requesting signature...');
+            // Sign transaction with wallet adapter
+            const signedTransaction = await connector.signTransaction(versionedTransaction);
+            console.log('Transaction signed');
+            // Send transaction using RPC directly (matching reference implementation pattern)
+            // Convert signed transaction to base64 for RPC
+            const signedTransactionBytes = signedTransaction.serialize();
+            const signedTransactionBase64 = Buffer.from(signedTransactionBytes).toString('base64'); // Type assertion for Base64EncodedWireTransaction
+            console.log('Sending transaction via RPC...');
+            // Use RPC sendTransaction with base64 encoding (matching reference implementation)
+            const signatureResponse = await rpc
+                .sendTransaction(signedTransactionBase64, {
+                encoding: 'base64',
+                skipPreflight: true,
+                preflightCommitment: 'confirmed',
+            })
+                .send();
+            const signatureString = signatureResponse;
+            console.log('Transaction sent:', signatureString);
+            // Wait for confirmation
+            // Use the adapter's confirmTransaction method
+            // Only confirm if we have blockhash and lastValidBlockHeight
+            let result;
+            if (blockhash && lastValidBlockHeight) {
+                console.log('Waiting for confirmation...');
+                result = await connection.confirmTransaction({
+                    signature: signatureString,
+                    blockhash,
+                    lastValidBlockHeight,
+                }, 'confirmed');
+                console.log('Transaction confirmed');
+            }
+            else {
+                // For transactions without blockhash info, return success
+                // The transaction will be confirmed by the network
+                console.log('No blockhash/lastValidBlockHeight, skipping confirmation');
+                result = {
+                    value: {
+                        err: null,
+                    },
+                };
+            }
+            // Check for errors
+            if (result.value.err) {
+                console.error('Transaction failed:', result.value.err);
+                throw new Error(`Solana transaction failed: ${result.value.err.toString()}`);
+            }
+            console.log('Transaction completed successfully:', signatureString);
+            return signatureString;
+        }
+        catch (error) {
+            console.error('Solana transaction execution failed:', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    };
+}
+/**
+ * Helper to convert relay.link Solana step data to BridgeTransaction
+ */
+export function convertRelaySolanaStepToTransaction(stepData, feePayer, chainId) {
+    return {
+        chainId,
+        feePayer,
+        instructions: stepData.instructions.map((inst) => ({
+            programId: inst.programId,
+            keys: inst.keys,
+            data: inst.data.startsWith('0x') ? inst.data : `0x${inst.data}`,
+        })),
+    };
+}

package/dist/hooks/silent/useAuth.d.ts

@@ -0,0 +1,90 @@
+import { createEip712DocForOrder, createEip712DocForWalletGeneration, type QuoteResponse, type SignInMessage, type AuthResponse } from '@silentswap/sdk';
+import type { SilentSwapClient } from '@silentswap/sdk';
+import type { WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+export interface useAuthOptions {
+    /** SilentSwap client instance */
+    client?: SilentSwapClient;
+    /** User's EVM address */
+    address?: `0x${string}`;
+    /** Wallet client for signing operations */
+    walletClient?: WalletClient;
+    /** Wagmi connector */
+    connector?: Connector;
+    /** Domain for SIWE message (defaults to window.location.host) */
+    domain?: string;
+    /** Whether to auto-authenticate when dependencies are available */
+    autoAuthenticate?: boolean;
+}
+export interface useAuthReturn {
+    auth: AuthResponse | null;
+    nonce: string | null;
+    isLoading: boolean;
+    error: Error | null;
+    createSignInMessage: (address: `0x${string}`, nonce: string, domain?: string) => SignInMessage;
+    createEip712DocForOrder: (quoteResponse: QuoteResponse) => ReturnType<typeof createEip712DocForOrder>;
+    createEip712DocForWalletGeneration: (scope: string, token: string) => ReturnType<typeof createEip712DocForWalletGeneration>;
+    getNonce: () => Promise<string>;
+    authenticate: () => Promise<AuthResponse | null>;
+    signIn: () => Promise<AuthResponse | null>;
+    signOut: () => void;
+    isAuthenticated: () => boolean;
+}
+/**
+ * React hook for SilentSwap authentication with full SIWE flow
+ *
+ * This hook provides:
+ * - SIWE authentication with nonce management
+ * - Automatic auth caching and restoration
+ * - Sign-in message creation and signing
+ * - Auth state management
+ * - Auto-authentication when dependencies are available
+ *
+ * @param options - Configuration options for authentication
+ * @returns Object with authentication state and methods
+ *
+ * @example
+ * ```typescript
+ * import { useAuth, useSilentClient } from '@silentswap/react';
+ * import { useWalletClient, useAccount } from 'wagmi';
+ *
+ * function MyComponent() {
+ *   const { address } = useAccount();
+ *   const { data: walletClient } = useWalletClient();
+ *   const client = useSilentClient({ config: { /* ... *\/ } }).client;
+ *
+ *   const {
+ *     auth,
+ *     isAuthenticated,
+ *     signIn,
+ *     signOut,
+ *     isLoading,
+ *     error
+ *   } = useAuth({
+ *     client,
+ *     address,
+ *     walletClient: walletClient as any,
+ *     autoAuthenticate: true,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && <div>Authenticating...</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *
+ *       {isAuthenticated() ? (
+ *         <div>
+ *           <p>Authenticated as {auth?.address}</p>
+ *           <button onClick={signOut}>Sign Out</button>
+ *         </div>
+ *       ) : (
+ *         <button onClick={signIn} disabled={isLoading}>
+ *           Sign In with Ethereum
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useAuth({ client, address, walletClient, domain, autoAuthenticate, }?: useAuthOptions): useAuthReturn;