@meshconnect/uwc-react 0.3.5 → 0.3.7

package/dist/hooks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './useConnection';
+export * from './useSwitchNetwork';
+export * from './useDisconnect';
+export * from './useSession';
+export * from './useWallets';
+export * from './useWallet';
+export * from './useNetworks';
+export * from './useSignMessage';
+export * from './useTransaction';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/useConnection.d.ts

@@ -0,0 +1,22 @@
+import type { UseConnectionReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for managing wallet connections with both injected and WalletConnect modes
+ * @param walletId - The ID of the wallet to connect to (e.g., 'metamask', 'trust')
+ * @returns Connection methods and state for both injected and WalletConnect modes
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { walletConnect, injected } = useConnection('metamask')
+ *
+ * // Connect with browser extension
+ * await injected.connect('eip155:1')
+ *
+ * // Connect with WalletConnect QR code
+ * await walletConnect.connect('eip155:1')
+ * if (walletConnect.connectionURI) {
+ *   // Display QR code with walletConnect.connectionURI
+ * }
+ * ```
+ */
+export declare function useConnection(walletId: string): UseConnectionReturn;
+//# sourceMappingURL=useConnection.d.ts.map

package/dist/hooks/useDisconnect.d.ts

@@ -0,0 +1,27 @@
+interface UseDisconnectReturn {
+    disconnect: () => Promise<void>;
+    isLoading: boolean;
+}
+/**
+ * Hook for disconnecting the current wallet
+ * @returns Disconnect function and loading state
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { disconnect, isLoading } = useDisconnect()
+ *
+ * const handleDisconnect = async () => {
+ *   await disconnect()
+ *   console.log('Wallet disconnected')
+ * }
+ *
+ * return (
+ *   <button onClick={handleDisconnect} disabled={isLoading}>
+ *     {isLoading ? 'Disconnecting...' : 'Disconnect'}
+ *   </button>
+ * )
+ * ```
+ */
+export declare function useDisconnect(): UseDisconnectReturn;
+export {};
+//# sourceMappingURL=useDisconnect.d.ts.map

package/dist/hooks/useNetworks.d.ts

@@ -0,0 +1,16 @@
+import type { Network } from '@meshconnect/uwc-types';
+/**
+ * Hook for accessing the list of configured networks
+ * @returns Array of network configurations
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const networks = useNetworks()
+ *
+ * networks.forEach(network => {
+ *   console.log(`${network.name}: ${network.id}`)
+ * })
+ * ```
+ */
+export declare function useNetworks(): Network[];
+//# sourceMappingURL=useNetworks.d.ts.map

package/dist/hooks/useSession.d.ts

@@ -0,0 +1,18 @@
+import type { UseSessionReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for accessing the current wallet session state
+ * @returns Session information including active address, network, and connection details
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { activeAddress, activeNetwork, availableNetworks } = useSession()
+ *
+ * if (activeAddress) {
+ *   console.log(`Connected: ${activeAddress}`)
+ *   console.log(`Network: ${activeNetwork?.name}`)
+ *   console.log(`Available networks: ${availableNetworks.length}`)
+ * }
+ * ```
+ */
+export declare function useSession(): UseSessionReturn;
+//# sourceMappingURL=useSession.d.ts.map

package/dist/hooks/useSignMessage.d.ts

@@ -0,0 +1,22 @@
+import type { UseSignMessageReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for signing messages with the connected wallet
+ * @returns Object containing signMessage function, loading state, and last signature
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { signMessage, isLoading, signature } = useSignMessage()
+ *
+ * const handleSign = async () => {
+ *   try {
+ *     const sig = await signMessage('Hello World')
+ *     console.log('Signature:', sig)
+ *     // signature state will also be updated with the result
+ *   } catch (error) {
+ *     console.error('Failed to sign:', error)
+ *   }
+ * }
+ * ```
+ */
+export declare function useSignMessage(): UseSignMessageReturn;
+//# sourceMappingURL=useSignMessage.d.ts.map

package/dist/hooks/useSwitchNetwork.d.ts

@@ -0,0 +1,28 @@
+import type { UseSwitchNetworkReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for switching networks on the connected wallet
+ * @returns Network switching function and loading states
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { switchNetwork, isLoading, isWaitingForUserApproval } = useSwitchNetwork()
+ *
+ * const handleSwitch = async () => {
+ *   try {
+ *     await switchNetwork('eip155:8453') // Switch to Base
+ *   } catch (error) {
+ *     console.error('Network switch failed:', error)
+ *   }
+ * }
+ *
+ * // Show loading UI
+ * if (isWaitingForUserApproval) {
+ *   return <div>Please approve in your wallet...</div>
+ * }
+ * if (isLoading) {
+ *   return <div>Switching network...</div>
+ * }
+ * ```
+ */
+export declare function useSwitchNetwork(): UseSwitchNetworkReturn;
+//# sourceMappingURL=useSwitchNetwork.d.ts.map

package/dist/hooks/useTransaction.d.ts

@@ -0,0 +1,25 @@
+import type { UseTransactionReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for sending transactions with the connected wallet
+ * @returns Object containing sendTransaction function, loading state, and transaction result
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { sendTransaction, isLoading, transactionResult } = useTransaction()
+ *
+ * const handleSend = async () => {
+ *   try {
+ *     const result = await sendTransaction({
+ *       to: '0x...',
+ *       amount: BigInt('1000000000000000000'),
+ *       from: session.activeAddress
+ *     })
+ *     console.log('Transaction hash:', result.hash)
+ *   } catch (error) {
+ *     console.error('Transaction failed:', error)
+ *   }
+ * }
+ * ```
+ */
+export declare function useTransaction(): UseTransactionReturn;
+//# sourceMappingURL=useTransaction.d.ts.map

package/dist/hooks/useWallet.d.ts

@@ -0,0 +1,17 @@
+import type { UseWalletReturn } from '@meshconnect/uwc-types';
+/**
+ * Hook for accessing a specific wallet configuration
+ * @param {string} walletId - The ID of the wallet to access
+ * @returns {UseWalletReturn} Object containing the wallet metadata and error if no wallet was found
+ * @throws {Error} when used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const { wallet, error } = useWallet('metamask')
+ * if (wallet) {
+ *   console.log(wallet.name) // 'MetaMask'
+ * } else {
+ *   console.log(error?.message) // 'Wallet not found'
+ * }
+ */
+export declare function useWallet(walletId: string): UseWalletReturn;
+//# sourceMappingURL=useWallet.d.ts.map

package/dist/hooks/useWallets.d.ts

@@ -0,0 +1,16 @@
+import type { WalletMetadata } from '@meshconnect/uwc-types';
+/**
+ * Hook for accessing the list of configured wallets
+ * @returns Array of wallet metadata including names, IDs, and supported networks
+ * @throws Error if used outside of ConnectionProvider
+ * @example
+ * ```tsx
+ * const wallets = useWallets()
+ *
+ * wallets.forEach(wallet => {
+ *   console.log(`${wallet.name}: ${wallet.id}`)
+ * })
+ * ```
+ */
+export declare function useWallets(): WalletMetadata[];
+//# sourceMappingURL=useWallets.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './providers';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/ConnectionProvider.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { UniversalWalletConnector } from '@meshconnect/uwc-core';
+import type { Session, Network, WalletMetadata, WalletConnectConfig } from '@meshconnect/uwc-types';
+interface ConnectionContextValue {
+    connector: UniversalWalletConnector;
+    session: Session;
+    wallets: WalletMetadata[];
+    networks: Network[];
+    isReady: boolean;
+}
+declare const ConnectionContext: React.Context<ConnectionContextValue | null>;
+interface ConnectionProviderProps {
+    children: React.ReactNode;
+    networks: Network[];
+    wallets: WalletMetadata[];
+    usingIntegratedBrowser?: boolean;
+    walletConnectConfig?: WalletConnectConfig;
+}
+export declare function ConnectionProvider({ children, networks, wallets, usingIntegratedBrowser, walletConnectConfig }: ConnectionProviderProps): import("react/jsx-runtime").JSX.Element;
+export { ConnectionContext };
+//# sourceMappingURL=ConnectionProvider.d.ts.map

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ConnectionProvider';
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-react",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "React hooks and components for Universal Wallet Connector",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "src"
   ],
   "dependencies": {
-    "@meshconnect/uwc-core": "0.2.15",
+    "@meshconnect/uwc-core": "0.2.17",
     "@meshconnect/uwc-types": "0.2.7"
   },
   "peerDependencies": {