@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/index.node.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Gala Launchpad SDK - Node.js Entry Point
+ *
+ * Full SDK export including Node.js utilities.
+ * Automatically selected via package.json exports in Node.js environments.
+ *
+ * For browser environments, use the browser entry point instead (index.browser.ts).
+ *
+ * @packageDocumentation
+ */
+export * from './index.browser';
+export { getEnv, getEnvOrThrow, loadEnvWithFallback, } from './utils/load-env';
+//# sourceMappingURL=index.node.d.ts.map

package/dist/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../src/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,iBAAiB,CAAC;AAIhC,OAAO,EACL,MAAM,EACN,aAAa,EACb,mBAAmB,GACpB,MAAM,kBAAkB,CAAC"}

package/dist/polyfills/file-global.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Global File API Polyfill for Node.js
+ *
+ * Defines File as a global in Node.js environments where it doesn't exist.
+ * This is required for Zod schemas that use z.instanceof(File) which execute
+ * at module load time before any conditional checks can be performed.
+ *
+ * In browser environments, the native File API is used.
+ *
+ * @see https://github.com/Gozala/web-file - web-file-polyfill documentation
+ */
+//# sourceMappingURL=file-global.d.ts.map

package/dist/polyfills/file-global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-global.d.ts","sourceRoot":"","sources":["../../src/polyfills/file-global.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/react/WalletContext.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Wallet Context
+ *
+ * React context provider for managing wallet state across components.
+ * Provides connection state, detected wallets, and actions for connecting/disconnecting.
+ *
+ * @packageDocumentation
+ */
+import { type ReactNode } from 'react';
+import type { WalletContextValue, WalletProviderProps } from './types';
+/**
+ * React context for wallet state
+ */
+export declare const WalletContext: import("react").Context<WalletContextValue>;
+/**
+ * Wallet context provider component
+ *
+ * Wraps your application to provide wallet state and actions to all child components.
+ *
+ * @example
+ * ```tsx
+ * import { WalletProvider, useWallet } from '@gala-chain/launchpad-sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <WalletProvider autoDetect onConnect={(addr) => console.log('Connected:', addr)}>
+ *       <MyApp />
+ *     </WalletProvider>
+ *   );
+ * }
+ *
+ * function MyApp() {
+ *   const { isConnected, address, detectedWallets, connectDetected } = useWallet();
+ *
+ *   if (!isConnected) {
+ *     return (
+ *       <div>
+ *         {detectedWallets.map(wallet => (
+ *           <button key={wallet.rdns} onClick={() => connectDetected(wallet)}>
+ *             Connect {wallet.name}
+ *           </button>
+ *         ))}
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return <div>Connected: {address}</div>;
+ * }
+ * ```
+ */
+export declare function WalletProvider({ children, autoDetect, initialProvider, autoConnect, onConnect, onDisconnect, onError, }: WalletProviderProps): ReactNode;
+/**
+ * Hook to access the wallet context
+ *
+ * Must be used within a WalletProvider.
+ *
+ * @throws Error if used outside of WalletProvider
+ */
+export declare function useWalletContext(): WalletContextValue;
+//# sourceMappingURL=WalletContext.d.ts.map

package/dist/react/WalletContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletContext.d.ts","sourceRoot":"","sources":["../../src/react/WalletContext.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAC;AAMf,OAAO,KAAK,EAEV,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AA6CjB;;GAEG;AACH,eAAO,MAAM,aAAa,6CAAyD,CAAC;AAOpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,UAAsB,EACtB,eAAe,EACf,WAAkB,EAClB,SAAS,EACT,YAAY,EACZ,OAAO,GACR,EAAE,mBAAmB,GAAG,SAAS,CA0MjC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAMrD"}

package/dist/react/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * React Wallet Integration
+ *
+ * React hooks and components for wallet integration in React applications.
+ * Provides context-based state management, wallet detection, and connection handling.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   WalletProvider,
+ *   useWallet,
+ *   useWalletConnection,
+ *   useWalletDetection,
+ * } from '@gala-chain/launchpad-sdk/react';
+ *
+ * // Wrap your app with WalletProvider
+ * function App() {
+ *   return (
+ *     <WalletProvider autoDetect>
+ *       <MyApp />
+ *     </WalletProvider>
+ *   );
+ * }
+ *
+ * // Use hooks in components
+ * function WalletButton() {
+ *   const { isConnected, address, disconnect } = useWallet();
+ *   const { wallets } = useWalletDetection();
+ *   const { connectDetected, isConnecting } = useWalletConnection();
+ *
+ *   if (isConnected) {
+ *     return (
+ *       <button onClick={disconnect}>
+ *         {address?.slice(0, 6)}...{address?.slice(-4)}
+ *       </button>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {wallets.map(wallet => (
+ *         <button
+ *           key={wallet.rdns}
+ *           onClick={() => connectDetected(wallet)}
+ *           disabled={isConnecting}
+ *         >
+ *           <img src={wallet.icon} alt="" />
+ *           {wallet.name}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { useWalletContext, WalletContext, WalletProvider } from './WalletContext';
+export { useGalaAddress, useIsWalletConnected, useWallet, useWalletAddress, useWalletProvider, } from './useWallet';
+export { useWalletConnection, type UseWalletConnectionReturn } from './useWalletConnection';
+export { useWalletDetection, type UseWalletDetectionReturn } from './useWalletDetection';
+export type { ConnectionStatus, WalletContextActions, WalletContextState, WalletContextValue, WalletProviderProps, } from './types';
+export type { DetectedWallet, Eip6963ProviderInfo, WalletConnectionState, WalletProvider as WalletProviderInterface, } from '../wallet/types';
+export { detectWallets, ExternalWalletProvider, GalaChainConnectProvider, KNOWN_WALLET_RDNS, PrivateKeyProvider, } from '../wallet';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAGH,OAAO,EAAE,gBAAgB,EAAC,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjF,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAG5F,OAAO,EAAE,kBAAkB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGzF,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,IAAI,uBAAuB,GAC1C,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,wBAAwB,EACxB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,WAAW,CAAC"}

package/dist/react/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * React Wallet Types
+ *
+ * Type definitions for the React wallet integration hooks and context.
+ *
+ * @packageDocumentation
+ */
+import type { ReactNode } from 'react';
+import type { DetectedWallet, WalletProvider } from '../wallet/types';
+/**
+ * Wallet context state
+ */
+export interface WalletContextState {
+    /** The currently connected wallet provider */
+    provider: WalletProvider | null;
+    /** The connected wallet address (0x format) */
+    address: string | null;
+    /** The connected wallet address in Gala format (eth|0x...) */
+    galaAddress: string | null;
+    /** Whether a wallet is currently connected */
+    isConnected: boolean;
+    /** Whether a connection is in progress */
+    isConnecting: boolean;
+    /** Whether wallets are being detected */
+    isDetecting: boolean;
+    /** Connection error if any */
+    error: Error | null;
+    /** List of detected wallets (EIP-6963) */
+    detectedWallets: DetectedWallet[];
+}
+/**
+ * Wallet context actions
+ */
+export interface WalletContextActions {
+    /** Connect to a wallet using a provider */
+    connect: (provider: WalletProvider) => Promise<string>;
+    /** Connect to a detected wallet by its info */
+    connectDetected: (wallet: DetectedWallet) => Promise<string>;
+    /** Disconnect from the current wallet */
+    disconnect: () => Promise<void>;
+    /** Set the wallet provider directly (for external state management) */
+    setProvider: (provider: WalletProvider | null) => void;
+    /** Refresh the list of detected wallets */
+    refreshWallets: () => Promise<void>;
+    /** Clear any connection error */
+    clearError: () => void;
+}
+/**
+ * Full wallet context value
+ */
+export interface WalletContextValue extends WalletContextState, WalletContextActions {
+}
+/**
+ * Wallet provider component props
+ */
+export interface WalletProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Auto-detect wallets on mount (default: true in browser) */
+    autoDetect?: boolean;
+    /** Initial wallet provider to use */
+    initialProvider?: WalletProvider;
+    /** Auto-connect if a provider is set (default: true) */
+    autoConnect?: boolean;
+    /** Callback when wallet connects */
+    onConnect?: (address: string, provider: WalletProvider) => void;
+    /** Callback when wallet disconnects */
+    onDisconnect?: () => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+}
+/**
+ * Connection status for useWalletConnection hook
+ */
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+//# sourceMappingURL=types.d.ts.map

package/dist/react/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/react/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,cAAc,EAAC,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAEhC,+CAA+C;IAC/C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IAErB,0CAA0C;IAC1C,YAAY,EAAE,OAAO,CAAC;IAEtB,yCAAyC;IACzC,WAAW,EAAE,OAAO,CAAC;IAErB,8BAA8B;IAC9B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB,0CAA0C;IAC1C,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,OAAO,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAEvD,+CAA+C;IAC/C,eAAe,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7D,yCAAyC;IACzC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC,uEAAuE;IACvE,WAAW,EAAE,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,CAAC;IAEvD,2CAA2C;IAC3C,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpC,iCAAiC;IACjC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB,EAAE,oBAAoB;CAAG;AAEvF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,uBAAuB;IACvB,QAAQ,EAAE,SAAS,CAAC;IAEpB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,qCAAqC;IACrC,eAAe,CAAC,EAAE,cAAc,CAAC;IAEjC,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,oCAAoC;IACpC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC;IAEhE,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAE1B,oCAAoC;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC"}

package/dist/react/useWallet.d.ts

@@ -0,0 +1,123 @@
+/**
+ * useWallet Hook
+ *
+ * Primary hook for accessing wallet state and actions.
+ * This is the main hook most applications will use.
+ *
+ * @packageDocumentation
+ */
+import type { WalletProvider } from '../wallet/types';
+import type { WalletContextValue } from './types';
+/**
+ * Hook to access the current wallet state and actions
+ *
+ * This is the primary hook for wallet integration. It provides:
+ * - Current connection state (address, isConnected, etc.)
+ * - Detected wallets list
+ * - Actions (connect, disconnect, etc.)
+ *
+ * @returns The complete wallet context value
+ *
+ * @example
+ * ```tsx
+ * import { useWallet } from '@gala-chain/launchpad-sdk/react';
+ *
+ * function WalletButton() {
+ *   const {
+ *     isConnected,
+ *     address,
+ *     isConnecting,
+ *     error,
+ *     detectedWallets,
+ *     connectDetected,
+ *     disconnect
+ *   } = useWallet();
+ *
+ *   if (isConnecting) {
+ *     return <button disabled>Connecting...</button>;
+ *   }
+ *
+ *   if (isConnected) {
+ *     return (
+ *       <div>
+ *         <span>{address?.slice(0, 6)}...{address?.slice(-4)}</span>
+ *         <button onClick={disconnect}>Disconnect</button>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {error && <p style={{ color: 'red' }}>{error.message}</p>}
+ *       {detectedWallets.map(wallet => (
+ *         <button
+ *           key={wallet.rdns}
+ *           onClick={() => connectDetected(wallet)}
+ *         >
+ *           <img src={wallet.icon} alt={wallet.name} width={24} />
+ *           {wallet.name}
+ *         </button>
+ *       ))}
+ *       {detectedWallets.length === 0 && (
+ *         <p>No wallets detected. Please install a wallet extension.</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useWallet(): WalletContextValue;
+/**
+ * Hook to get just the wallet address
+ *
+ * @returns The connected address or null
+ *
+ * @example
+ * ```tsx
+ * const address = useWalletAddress();
+ * console.log('Connected to:', address);
+ * ```
+ */
+export declare function useWalletAddress(): string | null;
+/**
+ * Hook to get the Gala-formatted address
+ *
+ * @returns The connected address in Gala format (eth|0x...) or null
+ *
+ * @example
+ * ```tsx
+ * const galaAddress = useGalaAddress();
+ * // Use with SDK methods that require Gala format
+ * sdk.fetchTokensHeld({ ownerAddress: galaAddress });
+ * ```
+ */
+export declare function useGalaAddress(): string | null;
+/**
+ * Hook to check if wallet is connected
+ *
+ * @returns True if a wallet is connected
+ *
+ * @example
+ * ```tsx
+ * const isConnected = useIsWalletConnected();
+ * if (isConnected) {
+ *   // Show authenticated content
+ * }
+ * ```
+ */
+export declare function useIsWalletConnected(): boolean;
+/**
+ * Hook to get the current wallet provider
+ *
+ * @returns The wallet provider or null
+ *
+ * @example
+ * ```tsx
+ * const provider = useWalletProvider();
+ * if (provider) {
+ *   const signature = await provider.signMessage('Hello');
+ * }
+ * ```
+ */
+export declare function useWalletProvider(): WalletProvider | null;
+//# sourceMappingURL=useWallet.d.ts.map

package/dist/react/useWallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWallet.d.ts","sourceRoot":"","sources":["../../src/react/useWallet.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,SAAS,IAAI,kBAAkB,CAE9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAGhD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAG9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAG9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,IAAI,CAGzD"}

package/dist/react/useWalletConnection.d.ts

@@ -0,0 +1,89 @@
+/**
+ * useWalletConnection Hook
+ *
+ * Hook for managing wallet connection lifecycle.
+ * Provides connection actions and status tracking.
+ *
+ * @packageDocumentation
+ */
+import type { DetectedWallet, WalletProvider } from '../wallet/types';
+import type { ConnectionStatus } from './types';
+/**
+ * Return type for useWalletConnection
+ */
+export interface UseWalletConnectionReturn {
+    /** Current connection status */
+    status: ConnectionStatus;
+    /** Whether currently connecting */
+    isConnecting: boolean;
+    /** Whether connected to a wallet */
+    isConnected: boolean;
+    /** Connection error if any */
+    error: Error | null;
+    /** Connect to a wallet provider */
+    connect: (provider: WalletProvider) => Promise<string>;
+    /** Connect to a detected wallet */
+    connectDetected: (wallet: DetectedWallet) => Promise<string>;
+    /** Disconnect from the current wallet */
+    disconnect: () => Promise<void>;
+    /** Clear any connection error */
+    clearError: () => void;
+}
+/**
+ * Hook for managing wallet connection
+ *
+ * Provides a focused interface for connection management:
+ * - Connection status tracking
+ * - Connect/disconnect actions
+ * - Error handling
+ *
+ * @returns Connection state and actions
+ *
+ * @example
+ * ```tsx
+ * import { useWalletConnection, useWalletDetection } from '@gala-chain/launchpad-sdk/react';
+ *
+ * function ConnectWallet() {
+ *   const { status, connect, disconnect, error, clearError } = useWalletConnection();
+ *   const { wallets } = useWalletDetection();
+ *
+ *   const handleConnect = async (wallet) => {
+ *     try {
+ *       await connect(new ExternalWalletProvider(wallet.provider));
+ *       console.log('Connected!');
+ *     } catch (err) {
+ *       console.error('Connection failed:', err);
+ *     }
+ *   };
+ *
+ *   switch (status) {
+ *     case 'connecting':
+ *       return <div>Connecting...</div>;
+ *
+ *     case 'connected':
+ *       return <button onClick={disconnect}>Disconnect</button>;
+ *
+ *     case 'error':
+ *       return (
+ *         <div>
+ *           <p>Error: {error?.message}</p>
+ *           <button onClick={clearError}>Try Again</button>
+ *         </div>
+ *       );
+ *
+ *     default:
+ *       return (
+ *         <div>
+ *           {wallets.map(w => (
+ *             <button key={w.info.rdns} onClick={() => handleConnect(w)}>
+ *               {w.info.name}
+ *             </button>
+ *           ))}
+ *         </div>
+ *       );
+ *   }
+ * }
+ * ```
+ */
+export declare function useWalletConnection(): UseWalletConnectionReturn;
+//# sourceMappingURL=useWalletConnection.d.ts.map

package/dist/react/useWalletConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletConnection.d.ts","sourceRoot":"","sources":["../../src/react/useWalletConnection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAC,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,gCAAgC;IAChC,MAAM,EAAE,gBAAgB,CAAC;IAEzB,mCAAmC;IACnC,YAAY,EAAE,OAAO,CAAC;IAEtB,oCAAoC;IACpC,WAAW,EAAE,OAAO,CAAC;IAErB,8BAA8B;IAC9B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB,mCAAmC;IACnC,OAAO,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAEvD,mCAAmC;IACnC,eAAe,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7D,yCAAyC;IACzC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC,iCAAiC;IACjC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,mBAAmB,IAAI,yBAAyB,CAgC/D"}

package/dist/react/useWalletDetection.d.ts

@@ -0,0 +1,81 @@
+/**
+ * useWalletDetection Hook
+ *
+ * Hook for detecting available browser wallets via EIP-6963.
+ * Provides the list of detected wallets and detection state.
+ *
+ * @packageDocumentation
+ */
+import type { DetectedWallet } from '../wallet/types';
+/**
+ * Return type for useWalletDetection
+ */
+export interface UseWalletDetectionReturn {
+    /** List of all detected wallets */
+    wallets: DetectedWallet[];
+    /** Whether wallet detection is in progress */
+    isDetecting: boolean;
+    /** Refresh the list of detected wallets */
+    refresh: () => Promise<void>;
+    /** Check if a specific wallet is available by RDNS */
+    hasWallet: (rdns: string) => boolean;
+    /** Get a wallet by its RDNS identifier */
+    getWallet: (rdns: string) => DetectedWallet | undefined;
+    /** Check if MetaMask is available */
+    hasMetaMask: boolean;
+    /** Check if Coinbase Wallet is available */
+    hasCoinbaseWallet: boolean;
+    /** Check if any wallet is available */
+    hasAnyWallet: boolean;
+}
+/**
+ * Hook for detecting available browser wallets
+ *
+ * Uses EIP-6963 to discover installed wallet extensions.
+ * Automatically updates when new wallets are detected.
+ *
+ * @returns Detection state and wallet list
+ *
+ * @example
+ * ```tsx
+ * import { useWalletDetection, useWalletConnection } from '@gala-chain/launchpad-sdk/react';
+ *
+ * function WalletSelector() {
+ *   const { wallets, isDetecting, hasAnyWallet, hasMetaMask } = useWalletDetection();
+ *   const { connectDetected } = useWalletConnection();
+ *
+ *   if (isDetecting) {
+ *     return <div>Detecting wallets...</div>;
+ *   }
+ *
+ *   if (!hasAnyWallet) {
+ *     return (
+ *       <div>
+ *         <p>No wallets detected.</p>
+ *         <a href="https://metamask.io/download/" target="_blank">
+ *           Install MetaMask
+ *         </a>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <h3>Select a wallet:</h3>
+ *       {wallets.map(wallet => (
+ *         <button
+ *           key={wallet.rdns}
+ *           onClick={() => connectDetected(wallet)}
+ *           style={{ display: 'flex', alignItems: 'center', gap: '8px' }}
+ *         >
+ *           <img src={wallet.icon} alt="" width={24} height={24} />
+ *           {wallet.name}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useWalletDetection(): UseWalletDetectionReturn;
+//# sourceMappingURL=useWalletDetection.d.ts.map

package/dist/react/useWalletDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletDetection.d.ts","sourceRoot":"","sources":["../../src/react/useWalletDetection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,mCAAmC;IACnC,OAAO,EAAE,cAAc,EAAE,CAAC;IAE1B,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IAErB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B,sDAAsD;IACtD,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAErC,0CAA0C;IAC1C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,CAAC;IAExD,qCAAqC;IACrC,WAAW,EAAE,OAAO,CAAC;IAErB,4CAA4C;IAC5C,iBAAiB,EAAE,OAAO,CAAC;IAE3B,uCAAuC;IACvC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,kBAAkB,IAAI,wBAAwB,CAkD7D"}