@solana/connector 0.0.0 → 0.1.1

package/dist/wallet-standard-shim-Cg0GVGwu.d.mts

@@ -0,0 +1,926 @@
+import { c as TransactionActivity, d as TransactionActivityStatus } from './transaction-signer-D3csM_Mf.mjs';
+import { SolanaClusterId, SolanaCluster } from '@wallet-ui/core';
+import { Wallet, WalletAccount } from '@wallet-standard/base';
+import { Address, Signature } from 'gill';
+import React, { ReactNode, Component, ErrorInfo } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Wallet-related types
+ * Re-exports from @wallet-standard/base and custom wallet types
+ */
+
+/**
+ * Wallet name as a branded string for type safety
+ * Represents the unique identifier for a wallet (e.g., "Phantom", "Solflare")
+ */
+type WalletName = string & {
+    readonly __brand: 'WalletName';
+};
+/**
+ * Account address as a branded string for type safety
+ * Represents a Solana address (base58-encoded public key)
+ *
+ * @deprecated Use `Address` from 'gill' instead for consistent address typing
+ */
+type AccountAddress = string & {
+    readonly __brand: 'AccountAddress';
+};
+/**
+ * Type guard to check if a string is a valid wallet name
+ */
+declare function isWalletName(value: string): value is WalletName;
+/**
+ * Type guard to check if a string is a valid account address
+ *
+ * @deprecated Use `isAddress` from 'gill' instead for proper address validation
+ */
+declare function isAccountAddress(value: string): value is AccountAddress;
+/**
+ * Extended wallet information with capability metadata
+ */
+interface WalletInfo {
+    /** The Wallet Standard wallet object */
+    wallet: Wallet;
+    /** Whether the wallet extension is installed */
+    installed: boolean;
+    /** Precomputed capability flag for UI convenience */
+    connectable?: boolean;
+}
+
+/**
+ * Storage-related types
+ */
+
+/**
+ * Storage adapter interface for connector persistence
+ */
+interface StorageAdapter<T> {
+    get(): T;
+    set(value: T): void;
+    subscribe?(callback: (value: T) => void): () => void;
+}
+/**
+ * Base options for enhanced storage instances
+ */
+interface BaseEnhancedStorageOptions<T> {
+    /** Storage key */
+    key?: string;
+    /** Initial value */
+    initial?: T;
+    /** Custom error handler for storage failures */
+    onError?: (error: Error) => void;
+}
+/**
+ * Options for creating enhanced storage instances with validation
+ */
+interface StorageOptions<T> extends BaseEnhancedStorageOptions<T> {
+    /** Validate before setting values */
+    validator?: (value: T) => boolean;
+    /** Use memory storage if localStorage unavailable (SSR) */
+    useMemoryFallback?: boolean;
+}
+/**
+ * Options for account storage
+ */
+interface EnhancedStorageAccountOptions extends BaseEnhancedStorageOptions<string | undefined> {
+    validator?: (value: string | undefined) => boolean;
+}
+/**
+ * Options for cluster storage
+ */
+interface EnhancedStorageClusterOptions extends BaseEnhancedStorageOptions<SolanaClusterId> {
+    validClusters?: SolanaClusterId[];
+}
+/**
+ * Options for wallet storage
+ */
+interface EnhancedStorageWalletOptions extends BaseEnhancedStorageOptions<string | undefined> {
+}
+
+/**
+ * Account-related types
+ */
+
+/**
+ * Extended account information with formatted address
+ */
+interface AccountInfo {
+    /** Formatted Solana address */
+    address: Address;
+    /** Optional account icon/avatar URL */
+    icon?: string;
+    /** Raw wallet account object from Wallet Standard */
+    raw: WalletAccount;
+}
+
+/**
+ * Core connector state
+ */
+interface ConnectorState {
+    wallets: WalletInfo[];
+    selectedWallet: Wallet | null;
+    connected: boolean;
+    connecting: boolean;
+    accounts: AccountInfo[];
+    selectedAccount: Address | null;
+    cluster: SolanaCluster | null;
+    clusters: SolanaCluster[];
+}
+/**
+ * State change listener function type
+ */
+type Listener = (s: ConnectorState) => void;
+/**
+ * Connector configuration options
+ */
+interface ConnectorConfig {
+    autoConnect?: boolean;
+    debug?: boolean;
+    /** Storage configuration using enhanced storage adapters */
+    storage?: {
+        account: StorageAdapter<string | undefined>;
+        cluster: StorageAdapter<SolanaClusterId>;
+        wallet: StorageAdapter<string | undefined>;
+    };
+    /** Enhanced cluster configuration using wallet-ui */
+    cluster?: {
+        clusters?: SolanaCluster[];
+        persistSelection?: boolean;
+        initialCluster?: SolanaClusterId;
+    };
+}
+/**
+ * Health check information for connector diagnostics
+ * Useful for debugging, monitoring, and support
+ */
+interface ConnectorHealth {
+    /** Whether the connector has been initialized */
+    initialized: boolean;
+    /** Whether Wallet Standard registry is available */
+    walletStandardAvailable: boolean;
+    /** Whether localStorage/storage is available */
+    storageAvailable: boolean;
+    /** Number of wallets currently detected */
+    walletsDetected: number;
+    /** List of errors encountered during initialization or operation */
+    errors: string[];
+    /** Current connection state */
+    connectionState: {
+        connected: boolean;
+        connecting: boolean;
+        hasSelectedWallet: boolean;
+        hasSelectedAccount: boolean;
+    };
+    /** Timestamp of health check */
+    timestamp: string;
+}
+/**
+ * Performance and debug metrics for monitoring
+ * Useful for identifying performance issues and optimization opportunities
+ */
+interface ConnectorDebugMetrics {
+    /** Total number of state updates that resulted in actual changes */
+    stateUpdates: number;
+    /** Number of state updates that were skipped (no changes detected) */
+    noopUpdates: number;
+    /** Percentage of updates that were optimized away */
+    optimizationRate: number;
+    /** Number of active event listeners */
+    eventListenerCount: number;
+    /** Number of state subscribers */
+    subscriptionCount: number;
+    /** Average time taken for state updates (in milliseconds) */
+    avgUpdateTimeMs: number;
+    /** Timestamp of last state update */
+    lastUpdateTime: number;
+}
+/**
+ * Debug state with transaction history
+ */
+interface ConnectorDebugState extends ConnectorDebugMetrics {
+    /** Recent transaction activity (limited by maxTransactions) */
+    transactions: TransactionActivity[];
+    /** Total transactions tracked in this session */
+    totalTransactions: number;
+}
+
+/**
+ * Event system types for connector
+ */
+
+/**
+ * Event types emitted by the connector
+ * Use these for analytics, logging, and custom behavior
+ */
+type ConnectorEvent = {
+    type: 'wallet:connected';
+    wallet: WalletName;
+    account: Address;
+    timestamp: string;
+} | {
+    type: 'wallet:disconnected';
+    timestamp: string;
+} | {
+    type: 'wallet:changed';
+    wallet: WalletName;
+    timestamp: string;
+} | {
+    type: 'account:changed';
+    account: Address;
+    timestamp: string;
+} | {
+    type: 'cluster:changed';
+    cluster: SolanaClusterId;
+    previousCluster: SolanaClusterId | null;
+    timestamp: string;
+} | {
+    type: 'wallets:detected';
+    count: number;
+    timestamp: string;
+} | {
+    type: 'error';
+    error: Error;
+    context: string;
+    timestamp: string;
+} | {
+    type: 'connecting';
+    wallet: WalletName;
+    timestamp: string;
+} | {
+    type: 'connection:failed';
+    wallet: WalletName;
+    error: string;
+    timestamp: string;
+} | {
+    type: 'transaction:tracked';
+    signature: Signature;
+    status: TransactionActivityStatus;
+    timestamp: string;
+} | {
+    type: 'transaction:updated';
+    signature: Signature;
+    status: TransactionActivityStatus;
+    timestamp: string;
+} | {
+    type: 'transaction:preparing';
+    transaction: Uint8Array;
+    size: number;
+    timestamp: string;
+} | {
+    type: 'transaction:simulated';
+    success: boolean;
+    computeUnits: number | null;
+    timestamp: string;
+} | {
+    type: 'transaction:signing';
+    timestamp: string;
+} | {
+    type: 'transaction:sent';
+    signature: Signature;
+    timestamp: string;
+} | {
+    type: 'storage:reset';
+    timestamp: string;
+};
+/**
+ * Event listener function type
+ */
+type ConnectorEventListener = (event: ConnectorEvent) => void;
+
+declare class ConnectorClient {
+    private stateManager;
+    private eventEmitter;
+    private walletDetector;
+    private connectionManager;
+    private autoConnector;
+    private clusterManager;
+    private transactionTracker;
+    private debugMetrics;
+    private healthMonitor;
+    private initialized;
+    private config;
+    constructor(config?: ConnectorConfig);
+    private initialize;
+    select(walletName: string): Promise<void>;
+    disconnect(): Promise<void>;
+    selectAccount(address: string): Promise<void>;
+    setCluster(clusterId: SolanaClusterId): Promise<void>;
+    getCluster(): SolanaCluster | null;
+    getClusters(): SolanaCluster[];
+    getRpcUrl(): string | null;
+    subscribe(listener: Listener): () => void;
+    getSnapshot(): ConnectorState;
+    resetStorage(): void;
+    on(listener: ConnectorEventListener): () => void;
+    off(listener: ConnectorEventListener): void;
+    offAll(): void;
+    emitEvent(event: ConnectorEvent): void;
+    trackTransaction(activity: Omit<TransactionActivity, 'timestamp' | 'cluster'>): void;
+    updateTransactionStatus(signature: string, status: TransactionActivity['status'], error?: string): void;
+    clearTransactionHistory(): void;
+    getHealth(): ConnectorHealth;
+    getDebugMetrics(): ConnectorDebugMetrics;
+    getDebugState(): ConnectorDebugState;
+    resetDebugMetrics(): void;
+    destroy(): void;
+}
+
+interface DefaultConfigOptions {
+    /** Application name shown in wallet connection prompts */
+    appName: string;
+    /** Application URL for wallet connection metadata */
+    appUrl?: string;
+    /** Enable automatic wallet reconnection on page load */
+    autoConnect?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Solana network to connect to (accepts both 'mainnet' and 'mainnet-beta' conventions) */
+    network?: 'mainnet' | 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+    /** Enable Mobile Wallet Adapter support */
+    enableMobile?: boolean;
+    /** Custom storage implementation */
+    storage?: ConnectorConfig['storage'];
+    /** Custom cluster configuration - overrides network if provided */
+    clusters?: SolanaCluster[];
+    /** Additional custom clusters to add to the default list */
+    customClusters?: SolanaCluster[];
+    /** Persist cluster selection across sessions */
+    persistClusterSelection?: boolean;
+    /** Custom storage key for cluster persistence */
+    clusterStorageKey?: string;
+    /** Enable error boundaries for automatic error handling (default: true) */
+    enableErrorBoundary?: boolean;
+    /** Maximum retry attempts for error recovery (default: 3) */
+    maxRetries?: number;
+    /** Custom error handler */
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+}
+/** Extended ConnectorConfig with app metadata */
+interface ExtendedConnectorConfig extends ConnectorConfig {
+    /** Application name for display and metadata */
+    appName?: string;
+    /** Application URL for metadata */
+    appUrl?: string;
+    /** Whether mobile wallet adapter is enabled */
+    enableMobile?: boolean;
+    /** Selected network for convenience (accepts both 'mainnet' and 'mainnet-beta' conventions) */
+    network?: 'mainnet' | 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+    /** Error boundary configuration */
+    errorBoundary?: {
+        /** Enable error boundaries (default: true) */
+        enabled?: boolean;
+        /** Maximum retry attempts (default: 3) */
+        maxRetries?: number;
+        /** Custom error handler */
+        onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+        /** Custom fallback component */
+        fallback?: (error: Error, retry: () => void) => React.ReactNode;
+    };
+}
+/**
+ * Creates a default connector configuration with sensible defaults for Solana applications
+ */
+declare function getDefaultConfig(options: DefaultConfigOptions): ExtendedConnectorConfig;
+/**
+ * Default Mobile Wallet Adapter configuration for Solana applications
+ */
+declare function getDefaultMobileConfig(options: {
+    appName: string;
+    appUrl?: string;
+    network?: 'mainnet' | 'mainnet-beta' | 'devnet' | 'testnet';
+}): {
+    appIdentity: {
+        name: string;
+        uri: string;
+        icon: string;
+    };
+    cluster: "mainnet" | "devnet" | "testnet" | "mainnet-beta";
+};
+
+declare global {
+    interface Window {
+        __connectorClient?: ConnectorClient;
+    }
+}
+type ConnectorSnapshot = ReturnType<ConnectorClient['getSnapshot']> & {
+    select: (walletName: string) => Promise<void>;
+    disconnect: () => Promise<void>;
+    selectAccount: (address: string) => Promise<void>;
+};
+interface MobileWalletAdapterConfig {
+    appIdentity: {
+        name: string;
+        uri?: string;
+        icon?: string;
+    };
+    remoteHostAuthority?: string;
+    chains?: readonly string[];
+    authorizationCache?: unknown;
+    chainSelector?: unknown;
+    onWalletNotFound?: (wallet: unknown) => Promise<void>;
+}
+declare function ConnectorProvider({ children, config, mobile, }: {
+    children: ReactNode;
+    config?: ExtendedConnectorConfig;
+    mobile?: MobileWalletAdapterConfig;
+}): react_jsx_runtime.JSX.Element;
+declare function useConnector(): ConnectorSnapshot;
+declare function useConnectorClient(): ConnectorClient | null;
+
+/**
+ * @solana/connector - Network utilities
+ *
+ * Utilities for translating between different Solana network naming conventions.
+ * Ensures compatibility with WalletUI (SolanaClusterId) and Gill types.
+ *
+ * Primary type: SolanaNetwork - normalized network names
+ * External integration: Use WalletUI's SolanaClusterId for cluster operations
+ */
+
+/**
+ * Normalized Solana network names
+ *
+ * This is the canonical network type used throughout the connector.
+ * Use `toClusterId()` to convert to WalletUI's SolanaClusterId format.
+ * Aligned with Gill's SolanaClusterMoniker type.
+ */
+type SolanaNetwork = 'mainnet' | 'devnet' | 'testnet' | 'localnet';
+/**
+ * Public RPC endpoints for each Solana network
+ *
+ * ⚠️ WARNING: These are public, rate-limited endpoints provided by Solana Labs.
+ * For production applications, use a dedicated RPC provider like:
+ * - Triton (https://triton.one)
+ * - Helius (https://helius.dev)
+ * - QuickNode (https://quicknode.com)
+ * - Alchemy (https://alchemy.com)
+ *
+ * Note: These values are now sourced from Gill's getPublicSolanaRpcUrl for consistency.
+ * Kept here for reference and backward compatibility.
+ */
+declare const PUBLIC_RPC_ENDPOINTS: Record<SolanaNetwork, string>;
+/**
+ * Normalize network name to standard format
+ * Accepts various naming conventions and returns the canonical SolanaNetwork format
+ *
+ * @example
+ * normalizeNetwork('mainnet-beta') // Returns: 'mainnet'
+ * normalizeNetwork('mainnet') // Returns: 'mainnet'
+ * normalizeNetwork('MAINNET') // Returns: 'mainnet'
+ */
+declare function normalizeNetwork(network: string): SolanaNetwork;
+/**
+ * Convert network name to WalletUI cluster ID format
+ *
+ * WalletUI uses the 'solana:network' format for cluster identification.
+ *
+ * @example
+ * toClusterId('mainnet') // Returns: 'solana:mainnet'
+ * toClusterId('mainnet-beta') // Returns: 'solana:mainnet' (normalized)
+ */
+declare function toClusterId(network: string): SolanaClusterId;
+/**
+ * Get the public RPC URL for a network
+ *
+ * ⚠️ Returns public, rate-limited endpoints. For production, use a dedicated RPC provider.
+ *
+ * Now uses Gill's getPublicSolanaRpcUrl for consistency with the Gill ecosystem.
+ * Falls back to localnet URL for unknown networks.
+ *
+ * @example
+ * getDefaultRpcUrl('mainnet') // Returns: 'https://api.mainnet-beta.solana.com'
+ * getDefaultRpcUrl('devnet') // Returns: 'https://api.devnet.solana.com'
+ */
+declare function getDefaultRpcUrl(network: string): string;
+/**
+ * Check if a network is mainnet
+ *
+ * @example
+ * isMainnet('mainnet') // Returns: true
+ * isMainnet('mainnet-beta') // Returns: true
+ * isMainnet('devnet') // Returns: false
+ */
+declare function isMainnet(network: string): boolean;
+/**
+ * Check if a network is devnet
+ *
+ * @example
+ * isDevnet('devnet') // Returns: true
+ * isDevnet('mainnet') // Returns: false
+ */
+declare function isDevnet(network: string): boolean;
+/**
+ * Check if a network is testnet
+ *
+ * @example
+ * isTestnet('testnet') // Returns: true
+ * isTestnet('mainnet') // Returns: false
+ */
+declare function isTestnet(network: string): boolean;
+/**
+ * Check if a network is localnet
+ *
+ * @example
+ * isLocalnet('localnet') // Returns: true
+ * isLocalnet('mainnet') // Returns: false
+ */
+declare function isLocalnet(network: string): boolean;
+/**
+ * Get a user-friendly display name for a network
+ *
+ * @example
+ * getNetworkDisplayName('mainnet-beta') // Returns: 'Mainnet'
+ * getNetworkDisplayName('devnet') // Returns: 'Devnet'
+ */
+declare function getNetworkDisplayName(network: string): string;
+
+/**
+ * @solana/connector - Unified configuration
+ *
+ * Simplified configuration for apps using ConnectorKit
+ * Eliminates config duplication and provides a single source of truth
+ */
+
+/**
+ * Options for creating a unified configuration
+ * Maintains type safety while providing flexibility
+ */
+interface UnifiedConfigOptions extends DefaultConfigOptions {
+    /**
+     * Custom RPC URL (optional - overrides default for network)
+     * Note: For production apps, use environment variables to avoid exposing API keys
+     * @see packages/connector/src/utils/cluster.ts for secure RPC URL patterns
+     */
+    rpcUrl?: string;
+}
+/**
+ * Unified configuration output
+ * Contains all configs needed for ConnectorKit and integrations
+ *
+ * Important: The `rpcUrl` property is intended for:
+ * 1. Server-side rendering (SSR) setup
+ * 2. Passing to external libraries that need RPC configuration
+ * 3. Development/testing environments
+ *
+ * For production client-side code, use the connector client's `getRpcUrl()` method
+ * which supports environment variable patterns and proxy configurations.
+ */
+interface UnifiedConfig {
+    /** ConnectorKit configuration */
+    connectorConfig: ExtendedConnectorConfig;
+    /** Mobile Wallet Adapter configuration (optional) */
+    mobile?: MobileWalletAdapterConfig;
+    /** Normalized network name ('mainnet', 'devnet', 'testnet', 'localnet') */
+    network: SolanaNetwork;
+    /**
+     * RPC endpoint URL
+     * For external library integration only - client code should use connector client
+     * @deprecated in client components - use `useConnectorClient().getRpcUrl()` instead
+     */
+    rpcUrl: string;
+    /** Application metadata */
+    app: {
+        name: string;
+        url: string;
+    };
+}
+/**
+ * Create a unified configuration for ConnectorKit
+ *
+ * This helper eliminates configuration duplication by creating all necessary
+ * configs from a single source of truth. It automatically handles network
+ * name translation between different conventions.
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { createConfig, AppProvider } from '@solana/connector';
+ *
+ * const config = createConfig({
+ *   appName: 'My App',
+ *   network: 'mainnet', // Works with 'mainnet' or 'mainnet-beta'
+ *   enableMobile: true
+ * });
+ *
+ * <AppProvider config={config}>
+ *   {children}
+ * </AppProvider>
+ * ```
+ *
+ * @example Integration with external libraries
+ * ```tsx
+ * import { createConfig, AppProvider } from '@solana/connector';
+ * import { ArmaProvider } from '@armadura/sdk';
+ *
+ * const config = createConfig({
+ *   appName: 'My App',
+ *   network: 'mainnet',
+ * });
+ *
+ * <AppProvider config={config}>
+ *   <ArmaProvider
+ *     config={{
+ *       network: config.network,
+ *       rpcUrl: config.rpcUrl, // Safe - for external library initialization
+ *       providers: [...]
+ *     }}
+ *     useConnector="auto"
+ *   >
+ *     {children}
+ *   </ArmaProvider>
+ * </AppProvider>
+ * ```
+ *
+ * @example Production with environment variables
+ * ```tsx
+ * // Use environment variables to avoid exposing API keys
+ * const config = createConfig({
+ *   appName: 'My App',
+ *   network: 'mainnet',
+ *   // RPC URL comes from process.env on server
+ *   // Client-side code should use connector client's getRpcUrl()
+ * });
+ * ```
+ *
+ * @example Custom clusters
+ * ```tsx
+ * const config = createConfig({
+ *   appName: 'My App',
+ *   network: 'mainnet',
+ *   customClusters: [
+ *     {
+ *       id: 'solana:custom',
+ *       label: 'Custom RPC',
+ *       url: process.env.CUSTOM_RPC_URL || 'https://...'
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+declare function createConfig(options: UnifiedConfigOptions): UnifiedConfig;
+/**
+ * Type guard to check if a config is a unified config
+ *
+ * @example
+ * ```ts
+ * if (isUnifiedConfig(someConfig)) {
+ *   // TypeScript knows this is UnifiedConfig
+ *   console.log(someConfig.network, someConfig.rpcUrl);
+ * }
+ * ```
+ */
+declare function isUnifiedConfig(config: unknown): config is UnifiedConfig;
+
+declare enum WalletErrorType {
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    TRANSACTION_FAILED = "TRANSACTION_FAILED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    WALLET_NOT_FOUND = "WALLET_NOT_FOUND",
+    USER_REJECTED = "USER_REJECTED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+interface WalletError extends Error {
+    type: WalletErrorType;
+    recoverable: boolean;
+    context?: Record<string, unknown>;
+    retryAction?: () => Promise<void>;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+    errorId: string;
+    retryCount: number;
+}
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: (error: WalletError, retry: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    maxRetries?: number;
+    enableRecovery?: boolean;
+}
+declare class ConnectorErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    private retryTimeouts;
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    componentWillUnmount(): void;
+    retry: () => void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+declare function withErrorBoundary<P extends object>(Component: React.ComponentType<P>, errorBoundaryProps?: Omit<ErrorBoundaryProps, 'children'>): {
+    (props: P): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * @solana/connector - Cluster utilities
+ *
+ * Utility functions for working with Solana clusters (networks)
+ */
+
+/**
+ * Cluster type enum for all supported Solana cluster types
+ */
+type ClusterType = 'mainnet' | 'devnet' | 'testnet' | 'localnet' | 'custom';
+declare function getClusterRpcUrl(cluster: SolanaCluster | string): string;
+declare function getClusterExplorerUrl(cluster: SolanaCluster, path?: string): string;
+declare function getTransactionUrl(signature: string, cluster: SolanaCluster): string;
+declare function getAddressUrl(address: string, cluster: SolanaCluster): string;
+declare function getTokenUrl(tokenAddress: string, cluster: SolanaCluster): string;
+declare function getBlockUrl(slot: number, cluster: SolanaCluster): string;
+declare function isMainnetCluster(cluster: SolanaCluster): boolean;
+declare function isDevnetCluster(cluster: SolanaCluster): boolean;
+declare function isTestnetCluster(cluster: SolanaCluster): boolean;
+declare function isLocalCluster(cluster: SolanaCluster): boolean;
+declare function getClusterName(cluster: SolanaCluster): string;
+declare function getClusterType(cluster: SolanaCluster): ClusterType;
+declare function getClusterChainId(cluster: SolanaCluster): `solana:${string}` | null;
+declare function getChainIdForWalletStandard(cluster: SolanaCluster): `solana:${string}` | null;
+
+/**
+ * @solana/connector - Enhanced Clipboard Utilities
+ *
+ * Comprehensive clipboard functionality with validation, formatting, fallbacks,
+ * and detailed error reporting for Solana addresses and transaction signatures.
+ */
+/**
+ * Types of errors that can occur during clipboard operations
+ */
+declare enum ClipboardErrorType {
+    /** Browser doesn't support clipboard API (neither modern nor legacy) */
+    NOT_SUPPORTED = "not_supported",
+    /** User denied clipboard permission or browser blocked the operation */
+    PERMISSION_DENIED = "permission_denied",
+    /** Running in server-side rendering context (no window/navigator) */
+    SSR = "ssr",
+    /** Empty or null value provided */
+    EMPTY_VALUE = "empty_value",
+    /** Value failed validation (invalid address/signature format) */
+    INVALID_VALUE = "invalid_value",
+    /** Unknown error occurred during copy operation */
+    UNKNOWN = "unknown"
+}
+/**
+ * Detailed result from clipboard operation
+ */
+interface ClipboardResult {
+    /** Whether the copy operation succeeded */
+    success: boolean;
+    /** Type of error if operation failed */
+    error?: ClipboardErrorType;
+    /** Human-readable error message */
+    errorMessage?: string;
+    /** Whether fallback method (execCommand) was used instead of modern API */
+    usedFallback?: boolean;
+    /** The actual value that was copied (after formatting) */
+    copiedValue?: string;
+}
+/**
+ * Options for clipboard copy operations
+ */
+interface CopyOptions {
+    /** Callback invoked on successful copy */
+    onSuccess?: () => void;
+    /** Callback invoked on copy failure */
+    onError?: (error: ClipboardErrorType, message: string) => void;
+    /** Format to use when copying ('full' = original, 'short' = truncated) */
+    format?: 'full' | 'short' | 'custom';
+    /** Custom formatter function (only used when format='custom') */
+    customFormatter?: (value: string) => string;
+    /** Custom validation function */
+    validate?: (value: string) => boolean;
+    /** Type of value being copied (enables built-in validation) */
+    validateType?: 'address' | 'signature' | 'none';
+    /** Whether to attempt fallback using execCommand for older browsers */
+    useFallback?: boolean;
+    /** Number of characters to show on each side when format='short' */
+    shortFormatChars?: number;
+}
+/**
+ * Check clipboard API availability
+ *
+ * @returns Object indicating which clipboard methods are available
+ *
+ * @example
+ * ```ts
+ * const { modern, fallback, available } = isClipboardAvailable();
+ * if (!available) {
+ *   console.warn('Clipboard not supported in this browser');
+ * }
+ * ```
+ */
+declare function isClipboardAvailable(): {
+    /** Modern Clipboard API (navigator.clipboard) is available */
+    modern: boolean;
+    /** Legacy execCommand fallback is available */
+    fallback: boolean;
+    /** At least one method is available */
+    available: boolean;
+};
+/**
+ * Copy text to clipboard with comprehensive error handling and features
+ *
+ * @param text - Text to copy to clipboard
+ * @param options - Configuration options for copy operation
+ * @returns Promise resolving to detailed result object
+ *
+ * @example Basic usage
+ * ```ts
+ * const result = await copyToClipboard('5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp...');
+ * if (result.success) {
+ *   console.log('Copied!');
+ * }
+ * ```
+ *
+ * @example With validation and formatting
+ * ```ts
+ * const result = await copyToClipboard(address, {
+ *   validateType: 'address',
+ *   format: 'short',
+ *   onSuccess: () => toast.success('Address copied!'),
+ *   onError: (type, msg) => toast.error(msg)
+ * });
+ * ```
+ *
+ * @example Custom formatting
+ * ```ts
+ * const result = await copyToClipboard(signature, {
+ *   format: 'custom',
+ *   customFormatter: (sig) => `Signature: ${sig}`,
+ *   onSuccess: () => setCopied(true)
+ * });
+ * ```
+ */
+declare function copyToClipboard(text: string, options?: CopyOptions): Promise<ClipboardResult>;
+/**
+ * Copy a Solana wallet address to clipboard with automatic validation
+ *
+ * @param address - Solana wallet address (base58 encoded public key)
+ * @param options - Copy options (validateType will be set to 'address' automatically)
+ * @returns Promise resolving to result object
+ *
+ * @example
+ * ```tsx
+ * function AddressButton({ address }: { address: string }) {
+ *   const [copied, setCopied] = useState(false);
+ *
+ *   const handleCopy = async () => {
+ *     const result = await copyAddressToClipboard(address, {
+ *       format: 'short',
+ *       onSuccess: () => {
+ *         setCopied(true);
+ *         setTimeout(() => setCopied(false), 2000);
+ *       }
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCopy}>
+ *       {formatAddress(address)} {copied && '✓'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function copyAddressToClipboard(address: string, options?: Omit<CopyOptions, 'validateType'>): Promise<ClipboardResult>;
+/**
+ * Copy a transaction signature to clipboard with automatic validation
+ *
+ * @param signature - Solana transaction signature (base58 encoded, 64 bytes)
+ * @param options - Copy options (validateType will be set to 'signature' automatically)
+ * @returns Promise resolving to result object
+ *
+ * @example
+ * ```tsx
+ * function TransactionRow({ signature }: { signature: string }) {
+ *   return (
+ *     <button
+ *       onClick={async () => {
+ *         const result = await copySignatureToClipboard(signature, {
+ *           onSuccess: () => toast.success('Signature copied!'),
+ *           onError: (type, msg) => toast.error(msg)
+ *         });
+ *       }}
+ *     >
+ *       Copy Signature
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function copySignatureToClipboard(signature: string, options?: Omit<CopyOptions, 'validateType'>): Promise<ClipboardResult>;
+
+interface WalletsRegistry {
+    get(): readonly Wallet[];
+    on(event: 'register' | 'unregister', callback: (wallet: Wallet) => void): () => void;
+}
+type WalletStandardWallet = Wallet;
+type WalletStandardAccount = WalletAccount;
+/**
+ * Get the wallets registry - simplified approach
+ */
+declare function getWalletsRegistry(): WalletsRegistry;
+
+export { getBlockUrl as $, type AccountInfo as A, type StorageOptions as B, ConnectorProvider as C, type DefaultConfigOptions as D, type ExtendedConnectorConfig as E, type EnhancedStorageAccountOptions as F, type EnhancedStorageClusterOptions as G, type EnhancedStorageWalletOptions as H, WalletErrorType as I, type WalletError as J, ClipboardErrorType as K, type Listener as L, type MobileWalletAdapterConfig as M, type ClipboardResult as N, type CopyOptions as O, isClipboardAvailable as P, copyToClipboard as Q, copyAddressToClipboard as R, type StorageAdapter as S, copySignatureToClipboard as T, type UnifiedConfigOptions as U, getClusterRpcUrl as V, type WalletInfo as W, getClusterExplorerUrl as X, getTransactionUrl as Y, getAddressUrl as Z, getTokenUrl as _, useConnectorClient as a, isMainnetCluster as a0, isDevnetCluster as a1, isTestnetCluster as a2, isLocalCluster as a3, getClusterName as a4, getClusterType as a5, getClusterChainId as a6, getChainIdForWalletStandard as a7, type SolanaNetwork as a8, PUBLIC_RPC_ENDPOINTS as a9, normalizeNetwork as aa, toClusterId as ab, getDefaultRpcUrl as ac, isMainnet as ad, isDevnet as ae, isTestnet as af, isLocalnet as ag, getNetworkDisplayName as ah, ConnectorErrorBoundary as b, type ConnectorSnapshot as c, type ConnectorConfig as d, type ConnectorState as e, type WalletStandardWallet as f, type WalletStandardAccount as g, type UnifiedConfig as h, type ClusterType as i, ConnectorClient as j, getWalletsRegistry as k, getDefaultConfig as l, getDefaultMobileConfig as m, createConfig as n, isUnifiedConfig as o, type WalletName as p, type AccountAddress as q, isWalletName as r, isAccountAddress as s, type ConnectorHealth as t, useConnector as u, type ConnectorDebugMetrics as v, withErrorBoundary as w, type ConnectorDebugState as x, type ConnectorEvent as y, type ConnectorEventListener as z };