@tuwaio/nova-connect 1.0.0-fix-test-alpha.51.1ef6db6 → 1.0.0-fix-test-alpha.53.a751bf7

package/dist/index.d.cts

@@ -1,10 +1,10 @@
+import { OrbitAdapter, WalletType } from '@tuwaio/orbit-core';
 import * as react from 'react';
 import react__default, { FC, ReactNode, ComponentPropsWithoutRef } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { TransactionPool, Transaction, TxAdapter } from '@tuwaio/pulsar-core';
 import { ISatelliteConnectStore } from '@tuwaio/satellite-core';
 import { StoreApi } from 'zustand/index';
-import { OrbitAdapter, WalletType } from '@tuwaio/orbit-core';
 import { Connector as Connector$1 } from '@tuwaio/satellite-react';
 import * as Select from '@radix-ui/react-select';
 
@@ -212,6 +212,56 @@ type ConnectButtonProps = InitialChains & Pick<NovaConnectProviderProps, 'store'
 
 declare function ConnectButton({ store, labels, ...props }: Pick<NovaConnectProviderProps, 'labels'> & ConnectButtonProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * ChainSelector - Main component for blockchain network selection
+ *
+ * This component provides a comprehensive interface for users to select between
+ * different blockchain networks. It automatically detects available chains from
+ * wallet configuration and renders an appropriate selector interface.
+ *
+ * Key features:
+ * - Automatic chain detection from wallet type and configuration
+ * - Responsive design with separate mobile/desktop interfaces
+ * - Asynchronous chain loading with fallback to synchronous operation
+ * - Single chain optimization (no selector needed for one chain)
+ * - Full accessibility support with screen reader compatibility
+ * - Integration with wallet switching functionality
+ * - Error handling and loading states
+ *
+ * Architecture:
+ * - Uses dynamic imports for better performance
+ * - Supports both sync and async chain resolution
+ * - Provides fallback behavior when adapters fail
+ * - Integrates with existing store and state management
+ *
+ * Visual behavior:
+ * - Desktop: Dropdown select with animated content
+ * - Mobile: Modal dialog with scrollable list
+ * - Single chain: Simple display with icon and name
+ * - Multiple chains: Full selector with network switching
+ *
+ * @param appChains - Configuration for supported blockchain networks
+ * @param solanaRPCUrls - RPC URLs configuration for Solana network
+ * @param store - State management store for wallet operations
+ * @returns JSX element representing the chain selector or null if no wallet
+ *
+ * @example
+ * ```tsx
+ * <ChainSelector
+ *   appChains={[
+ *     { id: 1, name: 'Ethereum' },
+ *     { id: 137, name: 'Polygon' }
+ *   ]}
+ *   solanaRPCUrls={{
+ *     'mainnet-beta': 'https://api.mainnet-beta.solana.com'
+ *   }}
+ *   store={walletStore}
+ * />
+ * ```
+ *
+ * @public
+ * @since 1.0.0
+ */
 declare function ChainSelector({ appChains, solanaRPCUrls, store }: InitialChains & Pick<ConnectButtonProps, 'store'>): react_jsx_runtime.JSX.Element | null;
 
 interface ChainListProps {
@@ -1489,29 +1539,546 @@ declare const defaultLabels: NovaConnectLabels;
 declare const ukrainianLabels: NovaConnectLabels;
 
 /**
- * Parameters for getting chains list by wallet type
+ * Parameters for retrieving chain lists based on wallet configuration.
+ *
+ * Combines chain configuration with wallet-specific requirements to determine
+ * which chains should be available for a given wallet type.
+ *
+ * @interface GetChainsListParams
+ * @extends InitialChains
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * const params: GetChainsListParams = {
+ *   walletType: WalletType.EVM_METAMASK,
+ *   appChains: [
+ *     { id: 1, name: 'Ethereum' },
+ *     { id: 137, name: 'Polygon' }
+ *   ],
+ *   chains: [1, 137] // Optional filter
+ * };
+ * ```
  */
 interface GetChainsListParams extends InitialChains {
-    /** The wallet type to get chains for */
+    /** The wallet type to determine chain compatibility */
     walletType: WalletType;
-    /** Optional array of chain identifiers to filter by */
+    /** Optional array of specific chain identifiers to filter or validate */
     chains?: ChainIdentifierArray;
 }
 /**
- * Safely extracts chains from active wallet with proper type checking
- * @param activeWallet - The wallet object to extract chains from
- * @returns Array of chain identifiers or undefined if not found
+ * Retrieves chain list for a specific wallet type with automatic adapter loading.
+ *
+ * This is the primary function for getting blockchain-compatible chains based on
+ * wallet type and configuration. It automatically determines the correct adapter,
+ * loads it if necessary, and falls back to safe defaults if loading fails.
+ *
+ * The function supports all major blockchain types:
+ * - EVM chains: Returns numeric chain IDs from app configuration
+ * - Solana clusters: Returns string cluster names from RPC configuration
+ * - Future blockchains: Extensible through the adapter pattern
+ *
+ * @param params - Configuration object with wallet type and chain data
+ * @returns Promise resolving to array of chain identifiers
+ *
+ * @example
+ * ```typescript
+ * // Get EVM chains for MetaMask
+ * const evmChains = await getChainsListByWalletType({
+ *   walletType: WalletType.EVM_METAMASK,
+ *   appChains: [
+ *     { id: 1, name: 'Ethereum' },
+ *     { id: 137, name: 'Polygon' }
+ *   ]
+ * });
+ * // Returns: [1, 137]
+ *
+ * // Get Solana clusters for Phantom
+ * const solanaClusters = await getChainsListByWalletType({
+ *   walletType: WalletType.SOLANA_PHANTOM,
+ *   solanaRPCUrls: {
+ *     'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+ *     'devnet': 'https://api.devnet.solana.com'
+ *   }
+ * });
+ * // Returns: ['mainnet-beta', 'devnet']
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getChainsListByWalletType(params: GetChainsListParams): Promise<(string | number)[]>;
+/**
+ * Synchronous version that only works with pre-loaded adapters.
+ *
+ * This function provides immediate results by using only adapters that have
+ * already been loaded into the registry cache. It will not trigger new
+ * loading operations, making it safe for synchronous contexts but potentially
+ * less complete than the async version.
+ *
+ * Use this function when:
+ * - You've pre-loaded adapters during app initialization
+ * - You need immediate results without async overhead
+ * - You're in a synchronous context where async calls aren't feasible
+ *
+ * @param params - Configuration object with wallet type and chain data
+ * @returns Array of chain identifiers (empty if adapter not loaded)
+ *
+ * @example
+ * ```typescript
+ * // Pre-load adapters first
+ * await preloadChainAdapters([OrbitAdapter.EVM, OrbitAdapter.SOLANA]);
+ *
+ * // Now safe to use sync version
+ * const chains = getChainsListByWalletTypeSync({
+ *   walletType: WalletType.EVM_METAMASK,
+ *   appChains: evmConfiguration
+ * });
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getChainsListByWalletTypeSync(params: GetChainsListParams): (string | number)[];
+/**
+ * Validates if a chain list conforms to EVM format (with adapter loading).
+ *
+ * Uses the EVM adapter to perform comprehensive validation, falling back to
+ * basic type checking if the adapter isn't available. EVM chains typically
+ * use numeric identifiers.
+ *
+ * @param chains - Array of chain identifiers to validate
+ * @returns Promise resolving to true if chains are valid for EVM
+ *
+ * @example
+ * ```typescript
+ * const isEvm = await isEvmChainList([1, 137, 56]); // true
+ * const notEvm = await isEvmChainList(['mainnet-beta']); // false
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isEvmChainList(chains: (string | number)[]): Promise<boolean>;
+/**
+ * Validates if a chain list conforms to Solana format (with adapter loading).
+ *
+ * Uses the Solana adapter to perform comprehensive validation, falling back to
+ * basic type checking if the adapter isn't available. Solana chains typically
+ * use string cluster names.
+ *
+ * @param chains - Array of chain identifiers to validate
+ * @returns Promise resolving to true if chains are valid for Solana
+ *
+ * @example
+ * ```typescript
+ * const isSolana = await isSolanaChainList(['mainnet-beta', 'devnet']); // true
+ * const notSolana = await isSolanaChainList([1, 137]); // false
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isSolanaChainList(chains: (string | number)[]): Promise<boolean>;
+/**
+ * Synchronous EVM chain list validation using pre-loaded adapters.
+ *
+ * Provides immediate validation results without triggering adapter loading.
+ * Falls back to basic type checking if adapter isn't pre-loaded.
+ *
+ * @param chains - Array of chain identifiers to validate
+ * @returns True if chains are valid for EVM
+ *
+ * @example
+ * ```typescript
+ * const isEvm = isEvmChainListSync([1, 137, 56]); // true (immediate result)
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isEvmChainListSync(chains: (string | number)[]): boolean;
+/**
+ * Synchronous Solana chain list validation using pre-loaded adapters.
+ *
+ * Provides immediate validation results without triggering adapter loading.
+ * Falls back to basic type checking if adapter isn't pre-loaded.
+ *
+ * @param chains - Array of chain identifiers to validate
+ * @returns True if chains are valid for Solana
+ *
+ * @example
+ * ```typescript
+ * const isSolana = isSolanaChainListSync(['mainnet-beta', 'devnet']); // true
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isSolanaChainListSync(chains: (string | number)[]): boolean;
+/**
+ * Retrieves all available Solana clusters from the current configuration.
+ *
+ * This function loads the Solana adapter and queries it for all configured
+ * cluster names. Useful for populating UI dropdowns or validating cluster
+ * availability before connection attempts.
+ *
+ * @returns Promise resolving to array of available cluster names
+ *
+ * @example
+ * ```typescript
+ * const clusters = await getAvailableSolanaClusters();
+ * console.log('Available clusters:', clusters);
+ * // Might log: ['mainnet-beta', 'devnet', 'testnet', 'localnet']
+ *
+ * // Use for UI population
+ * const clusterOptions = clusters.map(cluster => ({
+ *   value: cluster,
+ *   label: cluster.replace('-', ' ').toUpperCase()
+ * }));
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getAvailableSolanaClusters$1(): Promise<string[]>;
+/**
+ * Validates whether a cluster name is valid for Solana connections.
+ *
+ * This function loads the Solana adapter and uses it to validate cluster
+ * names against known Solana cluster monikers and custom configurations.
+ *
+ * @param cluster - Cluster name to validate
+ * @returns Promise resolving to true if cluster is valid
+ *
+ * @example
+ * ```typescript
+ * const isValid = await isValidSolanaCluster('mainnet-beta'); // true
+ * const isInvalid = await isValidSolanaCluster('invalid-cluster'); // false
+ *
+ * // Use for form validation
+ * if (await isValidSolanaCluster(userInput)) {
+ *   // Proceed with connection
+ * } else {
+ *   // Show error message
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isValidSolanaCluster$1(cluster: string): Promise<boolean>;
+/**
+ * Safely extracts chain information from a wallet object.
+ *
+ * This utility function handles the complex nested structure of wallet objects
+ * and safely extracts chain information without throwing errors. It performs
+ * comprehensive type checking to ensure data integrity.
+ *
+ * The function expects wallet objects with this structure:
+ * ```
+ * {
+ *   connectedWallet: {
+ *     chains: [chain1, chain2, ...]
+ *   }
+ * }
+ * ```
+ *
+ * @param activeWallet - Wallet object to extract chains from
+ * @returns Array of chain identifiers or undefined if not found/invalid
+ *
+ * @example
+ * ```typescript
+ * // With valid wallet structure
+ * const wallet = {
+ *   connectedWallet: {
+ *     chains: [1, 137, 56]
+ *   }
+ * };
+ * const chains = getWalletChains(wallet); // [1, 137, 56]
+ *
+ * // With invalid/missing structure
+ * const invalidWallet = { someOtherProperty: true };
+ * const noChains = getWalletChains(invalidWallet); // undefined
+ *
+ * // Use in conditional logic
+ * const walletChains = getWalletChains(activeWallet);
+ * if (walletChains) {
+ *   console.log('Wallet supports chains:', walletChains);
+ * }
+ * ```
+ *
+ * @since 1.0.0
  */
 declare function getWalletChains(activeWallet: any): (string | number)[] | undefined;
 /**
- * Gets the list of available chains for a specific wallet type.
- * Automatically handles different blockchain adapters based on wallet type.
- * Now with enhanced safety for any types.
+ * Pre-loads blockchain adapters for improved application performance.
+ *
+ * This function should be called during application initialization to load
+ * commonly used adapters ahead of time. This eliminates loading delays when
+ * users first interact with wallet connections.
+ *
+ * All loading operations run concurrently for maximum efficiency, and the
+ * function completes even if some adapters fail to load (partial success).
+ *
+ * @param types - Array of adapter types to preload (defaults to EVM and Solana)
+ * @returns Promise that resolves when all loading attempts complete
+ *
+ * @example
+ * ```typescript
+ * // During app initialization
+ * export async function initializeApp() {
+ *   // Preload common adapters
+ *   await preloadChainAdapters([OrbitAdapter.EVM, OrbitAdapter.SOLANA]);
+ *
+ *   // Continue with other initialization
+ *   // ...
+ * }
+ *
+ * // Later usage will be instant for loaded adapters
+ * const evmChains = getChainsListByWalletTypeSync({
+ *   walletType: WalletType.EVM_METAMASK,
+ *   appChains: configuration
+ * }); // Instant result since adapter is pre-loaded
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function preloadChainAdapters(types?: OrbitAdapter[]): Promise<void>;
+/**
+ * Gets the current loading status of a specific adapter.
+ *
+ * Returns the current state of an adapter in the loading lifecycle. Useful
+ * for UI indicators, debugging, or conditional logic based on adapter
+ * availability.
+ *
+ * @param type - The adapter type to check
+ * @returns Current loading status of the adapter
+ *
+ * @example
+ * ```typescript
+ * const evmStatus = getAdapterStatus(OrbitAdapter.EVM);
+ *
+ * switch (evmStatus) {
+ *   case 'idle':
+ *     console.log('EVM adapter not yet requested');
+ *     break;
+ *   case 'loading':
+ *     // Show loading spinner
+ *     break;
+ *   case 'loaded':
+ *     // Enable EVM features
+ *     break;
+ *   case 'error':
+ *     // Show fallback UI
+ *     break;
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getAdapterStatus(type: OrbitAdapter): AdapterLoadStatus;
+/**
+ * Gets comprehensive status information for all registered adapters.
+ *
+ * Returns a complete overview of all adapter states, useful for debugging,
+ * monitoring, or displaying system status in admin interfaces.
+ *
+ * @returns Record mapping adapter types to their current loading status
+ *
+ * @example
+ * ```typescript
+ * const allStatuses = getAllAdaptersStatus();
+ * console.log('System overview:', allStatuses);
+ * // Output: { "evm": "loaded", "solana": "loading", "starknet": "idle" }
+ *
+ * // Use for system health monitoring
+ * const loadedAdapters = Object.entries(allStatuses)
+ *   .filter(([_, status]) => status === 'loaded')
+ *   .map(([type, _]) => type);
+ *
+ * console.log('Available blockchain support:', loadedAdapters);
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getAllAdaptersStatus(): Record<string, AdapterLoadStatus>;
+
+/**
+ * Generic chain adapter interface that provides blockchain-specific functionality.
+ *
+ * This interface abstracts the differences between various blockchain architectures
+ * (EVM, Solana, Starknet, etc.) while providing a consistent API for chain operations.
+ * Each adapter implementation handles the specifics of its blockchain type.
+ *
+ * @interface ChainAdapter
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * // EVM adapter usage
+ * const evmAdapter = await createEvmAdapter();
+ * const evmChains = evmAdapter.getChains([
+ *   { id: 1, name: 'Ethereum' },
+ *   { id: 137, name: 'Polygon' }
+ * ]);
+ *
+ * // Solana adapter usage
+ * const solanaAdapter = await createSolanaAdapter();
+ * const solanaClusters = solanaAdapter.getChains({
+ *   'mainnet-beta': 'https://api.mainnet-beta.solana.com'
+ * });
+ * ```
+ */
+interface ChainAdapter {
+    /**
+     * Extracts chain identifiers from the provided configuration.
+     *
+     * The exact behavior depends on the blockchain type:
+     * - EVM: Extracts numeric chain IDs from chain objects or arrays
+     * - Solana: Extracts cluster names from RPC URL configurations
+     * - Others: Implementation-specific logic
+     *
+     * @param config Chain configuration data (format varies by blockchain)
+     * @param chains Optional array of specific chains to filter or process
+     * @returns Array of chain identifiers (numbers for EVM, strings for Solana)
+     *
+     * @example
+     * ```typescript
+     * // EVM chains
+     * const evmChains = adapter.getChains([
+     *   { id: 1, name: 'Ethereum' },
+     *   { id: 56, name: 'BSC' }
+     * ]);
+     * // Returns: [1, 56]
+     *
+     * // Solana clusters
+     * const solanaClusters = adapter.getChains({
+     *   'mainnet-beta': 'https://api.mainnet-beta.solana.com',
+     *   devnet: 'https://api.devnet.solana.com'
+     * });
+     * // Returns: ['mainnet-beta', 'devnet']
+     * ```
+     */
+    getChains(config: any, chains?: any): (string | number)[];
+    /**
+     * Validates whether a chain identifier array conforms to this adapter's expected format.
+     *
+     * Different blockchains use different identifier formats:
+     * - EVM: Typically numeric chain IDs (e.g., 1, 137, 56)
+     * - Solana: String cluster names (e.g., 'mainnet-beta', 'devnet')
+     * - Others: Implementation-specific validation rules
+     *
+     * @param chains Array of chain identifiers to validate
+     * @returns True if the chain list format is valid for this blockchain type
+     *
+     * @example
+     * ```typescript
+     * // EVM validation
+     * const evmValid = evmAdapter.isChainList([1, 137, 56]); // true
+     * const evmInvalid = evmAdapter.isChainList(['mainnet']); // false
+     *
+     * // Solana validation
+     * const solanaValid = solanaAdapter.isChainList(['mainnet-beta', 'devnet']); // true
+     * const solanaInvalid = solanaAdapter.isChainList([1, 2]); // false
+     * ```
+     */
+    isChainList(chains: (string | number)[]): boolean;
+    /**
+     * Gets all available clusters for Solana-based adapters.
+     *
+     * This method is specific to Solana and returns the configured cluster names
+     * that can be used for connections. Not applicable to other blockchain types.
+     *
+     * @returns Array of available cluster names
+     * @optional This method is only available on Solana adapters
+     *
+     * @example
+     * ```typescript
+     * const solanaAdapter = await createSolanaAdapter();
+     * const clusters = solanaAdapter.getAvailableClusters?.();
+     * // Might return: ['mainnet-beta', 'devnet', 'testnet', 'localnet']
+     * ```
+     */
+    getAvailableClusters?(): string[];
+    /**
+     * Validates whether a cluster name is valid for Solana.
+     *
+     * This method is specific to Solana and checks if the provided cluster name
+     * is a known/valid Solana cluster moniker. Not applicable to other blockchain types.
+     *
+     * @param cluster Cluster name to validate
+     * @returns True if the cluster name is valid for Solana
+     * @optional This method is only available on Solana adapters
+     *
+     * @example
+     * ```typescript
+     * const solanaAdapter = await createSolanaAdapter();
+     * const isValid = solanaAdapter.isValidCluster?.('mainnet-beta'); // true
+     * const isInvalid = solanaAdapter.isValidCluster?.('invalid-cluster'); // false
+     * ```
+     */
+    isValidCluster?(cluster: string): boolean;
+}
+/**
+ * Represents the current loading state of a blockchain adapter.
+ *
+ * The adapter lifecycle progresses through these states:
+ * - `idle`: Adapter hasn't been requested yet
+ * - `loading`: Adapter is currently being loaded/initialized
+ * - `loaded`: Adapter is successfully loaded and ready for use
+ * - `error`: Adapter failed to load due to missing dependencies or errors
+ *
+ * @type AdapterLoadStatus
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * import { adapterRegistry } from './registry';
+ *
+ * const status = adapterRegistry.getAdapterStatus(OrbitAdapter.EVM);
+ *
+ * switch (status) {
+ *   case 'idle':
+ *     console.log('EVM adapter not yet requested');
+ *     break;
+ *   case 'loading':
+ *     console.log('EVM adapter is loading...');
+ *     break;
+ *   case 'loaded':
+ *     console.log('EVM adapter ready for use');
+ *     break;
+ *   case 'error':
+ *     console.log('EVM adapter failed to load');
+ *     break;
+ * }
+ * ```
+ */
+type AdapterLoadStatus = 'idle' | 'loading' | 'loaded' | 'error';
+/**
+ * Complete information about an adapter's loading state and instance.
+ *
+ * This interface tracks both the loading status and the actual adapter instance
+ * (if successfully loaded), along with any error information if loading failed.
  *
- * @param params - Configuration object containing wallet type and chain information
- * @returns Array of chain identifiers available for the given wallet type
+ * @interface AdapterInfo
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * // Internal registry usage (not typically used directly)
+ * const adapterInfo: AdapterInfo = {
+ *   status: 'loaded',
+ *   adapter: evmAdapterInstance
+ * };
+ *
+ * // Error case
+ * const errorInfo: AdapterInfo = {
+ *   status: 'error',
+ *   error: new Error('EVM utilities not available')
+ * };
+ * ```
  */
-declare function getChainsListByWalletType(params: GetChainsListParams): (string | number)[];
+interface AdapterInfo {
+    /** Current loading status of the adapter */
+    status: AdapterLoadStatus;
+    /** The loaded adapter instance (only present when status is 'loaded') */
+    adapter?: ChainAdapter;
+    /** Error information (only present when status is 'error') */
+    error?: Error;
+}
 
 /**
  * Gets the appropriate chain ID for connecting based on the selected adapter.
@@ -1541,6 +2108,19 @@ interface GroupedConnector {
         adapter: OrbitAdapter;
     })[];
 }
+interface GetGroupedConnectorsParams {
+    connectors: Partial<Record<OrbitAdapter, Connector$1[]>>;
+    excludeConnectors?: string[];
+}
+/**
+ * Groups wallet connectors by their formatted names across different adapters.
+ * Filters out specified excluded connectors (like 'injected' wallets).
+ */
+declare function getGroupedConnectors({ connectors, excludeConnectors }?: GetGroupedConnectorsParams): GroupedConnector[];
+/**
+ * Quick helper to check if connectors are available
+ */
+declare function hasAvailableConnectors(connectors: Partial<Record<OrbitAdapter, Connector$1[]>>): boolean;
 
 interface GetFilteredConnectorsParams {
     connectors: Partial<Record<OrbitAdapter, Connector$1[]>>;
@@ -1593,15 +2173,256 @@ declare const networksLinks: Partial<Record<OrbitAdapter, {
     about: string;
 }>>;
 
-declare const EvmChain: any;
-declare const getEvmChains: any;
-declare const isEvmChainList: any;
-declare const restEvmExports: any;
-declare const SolanaClusterMoniker: any;
-declare const getSolanaClusters: any;
-declare const isSolanaChainList: any;
-declare const getAvailableSolanaClusters: any;
-declare const isValidSolanaCluster: any;
-declare const restSolanaExports: any;
+/**
+ * @fileoverview Central export hub for blockchain utility functions and types.
+ *
+ * This module provides a unified interface for accessing blockchain-related utilities,
+ * offering both synchronous and asynchronous versions of functions to support different
+ * usage patterns and performance requirements.
+ *
+ * Export Strategy:
+ * - Synchronous functions by default for backward compatibility
+ * - Asynchronous versions with "Async" suffix for better performance
+ * - Adapter management functions for system control
+ * - Type exports for TypeScript integration
+ *
+ * @example
+ * ```typescript
+ * // Import synchronous version (backward compatible)
+ * import { getChainsListByWalletType, isEvmChainList } from './utils';
+ *
+ * // Import asynchronous version (better performance)
+ * import {
+ *   getChainsListByWalletTypeAsync,
+ *   isEvmChainListAsync
+ * } from './utils';
+ *
+ * // Import adapter management
+ * import { preloadChainAdapters, getAdapterStatus } from './utils';
+ *
+ * // Import types
+ * import type { ChainAdapter, AdapterLoadStatus } from './utils';
+ * ```
+ *
+ * @since 1.0.0
+ */
+/**
+ * Re-export all functions from the main chain utilities module.
+ * This includes both sync and async versions with proper naming.
+ */
+
+/**
+ * Synchronous fallback for getting available Solana clusters.
+ *
+ * This function provides immediate results but with limited functionality.
+ * It serves as a compatibility layer for synchronous contexts where the
+ * async version cannot be used.
+ *
+ * @returns Empty array with warning (use async version for real results)
+ *
+ * @example
+ * ```typescript
+ * // Synchronous fallback (limited functionality)
+ * const clusters = getAvailableSolanaClusters(); // []
+ *
+ * // Preferred async version (full functionality)
+ * const clustersAsync = await getAvailableSolanaClustersAsync();
+ * ```
+ *
+ * @since 1.0.0
+ * @deprecated Use getAvailableSolanaClustersAsync for full functionality
+ */
+declare function getAvailableSolanaClusters(): string[];
+/**
+ * Synchronous fallback for Solana cluster validation.
+ *
+ * This function provides basic validation against known cluster names but
+ * lacks the comprehensive validation logic of the async version. It performs
+ * a simple lookup against standard Solana cluster monikers.
+ *
+ * @param cluster - Cluster name to validate
+ * @returns True if cluster name matches known standard clusters
+ *
+ * @example
+ * ```typescript
+ * // Synchronous fallback (basic validation)
+ * const isValid = isValidSolanaCluster('mainnet-beta'); // true
+ * const isCustom = isValidSolanaCluster('custom-cluster'); // false
+ *
+ * // Preferred async version (comprehensive validation)
+ * const isValidAsync = await isValidSolanaClusterAsync('custom-cluster');
+ * ```
+ *
+ * @since 1.0.0
+ * @deprecated Use isValidSolanaClusterAsync for comprehensive validation
+ */
+declare function isValidSolanaCluster(cluster: string): boolean;
+
+/**
+ * Information about available blockchain-specific utilities and their status.
+ *
+ * @interface BlockchainUtilities
+ * @since 1.0.0
+ *
+ * @example
+ * ```typescript
+ * const utilities = await getBlockchainUtilities();
+ *
+ * if (utilities.hasEvmUtils) {
+ *   console.log('EVM utilities are available');
+ * }
+ *
+ * console.log('Adapter statuses:', utilities.adaptersStatus);
+ * ```
+ */
+interface BlockchainUtilities {
+    /** Whether EVM utilities are available and loaded */
+    hasEvmUtils: boolean;
+    /** Whether Solana utilities are available and loaded */
+    hasSolanaUtils: boolean;
+    /** Current loading status of all registered adapters */
+    adaptersStatus: Record<string, string>;
+}
+/**
+ * Gets comprehensive information about available blockchain utilities and their loading status.
+ * This function dynamically checks which blockchain adapters are available and their current state.
+ *
+ * @returns Promise resolving to blockchain utilities information
+ *
+ * @example
+ * ```typescript
+ * // Check what's available in your current setup
+ * const info = await getBlockchainUtilities();
+ *
+ * if (info.hasEvmUtils && info.hasSolanaUtils) {
+ *   console.log('Full multi-chain support available');
+ * } else {
+ *   console.log('Limited blockchain support:', info.adaptersStatus);
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getBlockchainUtilities(): Promise<BlockchainUtilities>;
+/**
+ * Result type for blockchain utility loading operations.
+ *
+ * @template T The type of utilities being loaded
+ *
+ * @since 1.0.0
+ */
+type BlockchainUtilityResult<T = any> = ({
+    available: true;
+} & T) | {
+    available: false;
+    error: string;
+};
+/**
+ * Dynamically loads EVM utilities if available in the current environment.
+ * Returns the utilities along with their availability status.
+ *
+ * @returns Promise resolving to EVM utilities or error information
+ *
+ * @example
+ * ```typescript
+ * const evmUtils = await getEvmUtils();
+ *
+ * if (evmUtils.available) {
+ *   // Use EVM-specific functions
+ *   const chains = evmUtils.getEvmChains(appChains);
+ *   console.log('Available EVM chains:', chains);
+ * } else {
+ *   console.warn('EVM not supported:', evmUtils.error);
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getEvmUtils(): Promise<BlockchainUtilityResult>;
+/**
+ * Dynamically loads Solana utilities if available in the current environment.
+ * Returns the utilities along with their availability status.
+ *
+ * @returns Promise resolving to Solana utilities or error information
+ *
+ * @example
+ * ```typescript
+ * const solanaUtils = await getSolanaUtils();
+ *
+ * if (solanaUtils.available) {
+ *   // Use Solana-specific functions
+ *   const clusters = solanaUtils.getSolanaClusters(rpcUrls);
+ *   console.log('Available Solana clusters:', clusters);
+ * } else {
+ *   console.warn('Solana not supported:', solanaUtils.error);
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function getSolanaUtils(): Promise<BlockchainUtilityResult>;
+/**
+ * Result of blockchain support initialization.
+ *
+ * @interface InitializationResult
+ * @since 1.0.0
+ */
+interface InitializationResult {
+    /** Whether EVM support was successfully initialized */
+    evm: boolean;
+    /** Whether Solana support was successfully initialized */
+    solana: boolean;
+    /** Array of error messages encountered during initialization */
+    errors: string[];
+}
+/**
+ * Preloads and initializes all available blockchain adapters.
+ * This function should be called during application startup for optimal performance.
+ * It attempts to load both EVM and Solana adapters and reports which ones are available.
+ *
+ * @returns Promise resolving to initialization results
+ *
+ * @example
+ * ```typescript
+ * // Call during app initialization
+ * const initResult = await initializeBlockchainSupport();
+ *
+ * if (initResult.evm && initResult.solana) {
+ *   console.log('Full blockchain support initialized');
+ * } else {
+ *   console.log('Partial support:', initResult);
+ *   if (initResult.errors.length > 0) {
+ *     console.warn('Initialization errors:', initResult.errors);
+ *   }
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function initializeBlockchainSupport(): Promise<InitializationResult>;
+/**
+ * Checks whether a specific blockchain adapter is supported in the current environment.
+ * This function performs runtime checks to determine adapter availability.
+ *
+ * @param adapter The blockchain adapter to check for support
+ * @returns Promise resolving to true if the adapter is supported
+ *
+ * @example
+ * ```typescript
+ * // Check individual adapter support
+ * const evmSupported = await isAdapterSupported(OrbitAdapter.EVM);
+ * const solanaSupported = await isAdapterSupported(OrbitAdapter.SOLANA);
+ * const starknetSupported = await isAdapterSupported(OrbitAdapter.Starknet);
+ *
+ * console.log('Adapter support:', {
+ *   evm: evmSupported,
+ *   solana: solanaSupported,
+ *   starknet: starknetSupported, // Currently always false
+ * });
+ * ```
+ *
+ * @since 1.0.0
+ */
+declare function isAdapterSupported(adapter: OrbitAdapter): Promise<boolean>;
 
-export { AboutWallets, type AllChainConfigs, type AllConnectors, type AllWallets, type ChainIdentifierArray, ChainListRenderer, ChainSelector, ConnectButton, type ConnectButtonProps, ConnectCard, ConnectedContent, ConnectedModal, ConnectedModalFooter, ConnectedModalMainContent, type ConnectedModalMainContentProps, ConnectedModalNameAndBalance, ConnectedModalTxHistory, Connecting, type Connector, ConnectorsBlock, ConnectorsSelections, type ConnectorsSelectionsProps, Disclaimer, EvmChain, GetWallet, IconButton, ImpersonateForm, type InitialChains, NetworkSelections, NetworkTabs, type NovaConnectLabels, RecentBadge, ScrollableChainList, SelectContentAnimated, SolanaClusterMoniker, StatusIcon, ToBottomButton, ToTopButton, ToastError, WaitForConnectionContent, type Wallet, WalletAvatar, type WalletAvatarProps, WalletIcon, defaultLabels, getAvailableChainIds, getAvailableSolanaClusters, getChainsListByWalletType, getConnectChainId, getEvmChains, getFilteredConnectors, getNetworkIcon, getSolanaClusters, getWalletChains, hasConnectorsForAdapter, isEvmChainList, isSolanaChainList, isTouchDevice, isValidSolanaCluster, networksLinks, restEvmExports, restSolanaExports, ukrainianLabels };
+export { AboutWallets, type AdapterInfo, type AdapterLoadStatus, type AllChainConfigs, type AllConnectors, type AllWallets, type BlockchainUtilities, type BlockchainUtilityResult, type ChainAdapter, type ChainIdentifierArray, ChainListRenderer, ChainSelector, ConnectButton, type ConnectButtonProps, ConnectCard, ConnectedContent, ConnectedModal, ConnectedModalFooter, ConnectedModalMainContent, type ConnectedModalMainContentProps, ConnectedModalNameAndBalance, ConnectedModalTxHistory, Connecting, type Connector, ConnectorsBlock, ConnectorsSelections, type ConnectorsSelectionsProps, Disclaimer, GetWallet, type GroupedConnector, IconButton, ImpersonateForm, type InitialChains, type InitializationResult, NetworkSelections, NetworkTabs, type NovaConnectLabels, RecentBadge, ScrollableChainList, SelectContentAnimated, StatusIcon, ToBottomButton, ToTopButton, ToastError, WaitForConnectionContent, type Wallet, WalletAvatar, type WalletAvatarProps, WalletIcon, defaultLabels, getAdapterStatus, getAllAdaptersStatus, getAvailableChainIds, getAvailableSolanaClusters, getAvailableSolanaClusters$1 as getAvailableSolanaClustersAsync, getBlockchainUtilities, getChainsListByWalletTypeSync as getChainsListByWalletType, getChainsListByWalletType as getChainsListByWalletTypeAsync, getChainsListByWalletTypeSync, getConnectChainId, getEvmUtils, getFilteredConnectors, getGroupedConnectors, getNetworkIcon, getSolanaUtils, getWalletChains, hasAvailableConnectors, hasConnectorsForAdapter, initializeBlockchainSupport, isAdapterSupported, isEvmChainListSync as isEvmChainList, isEvmChainList as isEvmChainListAsync, isEvmChainListSync, isSolanaChainListSync as isSolanaChainList, isSolanaChainList as isSolanaChainListAsync, isSolanaChainListSync, isTouchDevice, isValidSolanaCluster, isValidSolanaCluster$1 as isValidSolanaClusterAsync, networksLinks, preloadChainAdapters, ukrainianLabels };