@tuwaio/nova-connect 0.6.0 → 0.7.1

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { TuwaErrorState, OrbitAdapter, ConnectorType, ChainIdentifierArray } from '@tuwaio/orbit-core';
-export { UseNovaSiwxOptions, WalletNameAndAvatarData, useGetWalletNameAndAvatar, useNovaSiwx, useWalletChainsList } from './hooks/index.js';
-import { N as NovaConnectProviderProps, C as ConnectContentType, a as ConnectedContentType, B as ButtonTxStatus, b as NovaConnectProviderType, I as InitialChains } from './useWalletNativeBalance-DrgdoQa-.js';
-export { A as AllChainConfigs, L as LabelCategory, c as LegalConfig, d as NativeBalanceResult, e as NovaConnectLabelsContext, f as NovaConnectProviderContext, g as NovaConnectProviderError, h as NovaSiwxWatcher, i as NovaSiwxWatcherProps, W as WalletBalance, j as createLabelsSubset, k as getLabelWithFallback, l as hasLabel, m as isDefaultLabels, u as useHasNovaConnectContext, n as useLabelsByCategory, o as useNovaConnect, p as useNovaConnectLabel, q as useNovaConnectLabels, r as useNovaConnectLabelsSubset, s as useNovaConnectOptional, t as useWalletNativeBalance } from './useWalletNativeBalance-DrgdoQa-.js';
+export { UseGetWalletNameAndAvatarOptions, UseNovaSiwxOptions, UseWalletChainsListProps, WalletNameAndAvatarData, useGetWalletNameAndAvatar, useNovaSiwx, useWalletChainsList } from './hooks/index.js';
+import { N as NovaConnectProviderProps, C as ConnectContentType, a as ConnectedContentType, B as ButtonTxStatus, b as NovaConnectProviderType, I as InitialChains } from './useWalletNativeBalance-CPK-PoXG.js';
+export { A as AllChainConfigs, L as LabelCategory, c as LegalConfig, d as NativeBalanceResult, e as NovaConnectAppChains, f as NovaConnectChainConfigTypes, g as NovaConnectLabelsContext, h as NovaConnectProviderContext, i as NovaConnectProviderError, j as NovaConnectSolanaRPCUrls, k as NovaSiwxWatcher, l as NovaSiwxWatcherProps, U as UseWalletNativeBalanceData, m as UseWalletNativeBalanceState, W as WalletBalance, n as createLabelsSubset, o as getLabelWithFallback, p as hasLabel, q as isDefaultLabels, u as useHasNovaConnectContext, r as useLabelsByCategory, s as useNovaConnect, t as useNovaConnectLabel, v as useNovaConnectLabels, w as useNovaConnectLabelsSubset, x as useNovaConnectOptional, y as useWalletNativeBalance } from './useWalletNativeBalance-CPK-PoXG.js';
 import * as React from 'react';
 import { ComponentPropsWithoutRef, ComponentType, ReactNode } from 'react';
 import { ToastCloseButtonProps } from '@tuwaio/nova-core';
+import { TuwaErrorState, ConnectorType, ChainIdentifierArray, OrbitAdapter } from '@tuwaio/orbit-core';
 import { ToastPosition, ToastContainer, toast } from 'react-toastify';
 import { ToastErrorCustomization, ConnectModalCustomization, ConnectedModalCustomization } from './components/index.js';
-import { N as NovaConnectLabels } from './types-DxUn8qmU.js';
+import { N as NovaConnectLabels } from './types-CnOiSyvZ.js';
 import { BaseConnector } from '@tuwaio/satellite-core';
 import { Connector } from '@tuwaio/satellite-react';
 import '@tuwaio/siwx-react';
@@ -15,14 +15,25 @@ import '@tuwaio/pulsar-core';
 import 'framer-motion';
 import '@radix-ui/react-select';
 
-type CustomToastErrorProps = {
+/** Props of the toast content of {@link ErrorsProvider} (`customization.components.ToastError`). */
+type ErrorsProviderToastErrorProps = {
+    /** The toast title (from `errorTitle`, by default the label of the error type). */
     title: string;
+    /** The error: `connectionError` or `switchNetworkError` of the Satellite Connect store. */
     rawError: string | TuwaErrorState;
+    /**
+     * Called after the error was copied (or not).
+     *
+     * @param success - Whether the error was copied.
+     */
     onCopyComplete?: (success: boolean) => void;
+    /** `'wallet'` for `connectionError`, `'switch'` for `switchNetworkError`. */
     errorType: 'wallet' | 'switch' | null;
+    /** Whether a wallet is connected. */
     isConnected: boolean;
 };
-type CustomContainerProps = ComponentPropsWithoutRef<typeof ToastContainer>;
+/** Props of the toast container of {@link ErrorsProvider}: the props of `ToastContainer` from `react-toastify`. */
+type ErrorsProviderContainerProps = ComponentPropsWithoutRef<typeof ToastContainer>;
 /**
  * Customization options for ErrorsProvider component
  */
@@ -32,9 +43,9 @@ type ErrorsProviderCustomization = {
     /** Custom components */
     components?: {
         /** Custom ToastError component */
-        ToastError?: ComponentType<CustomToastErrorProps>;
+        ToastError?: ComponentType<ErrorsProviderToastErrorProps>;
         /** Custom ToastContainer component */
-        Container?: ComponentType<CustomContainerProps>;
+        Container?: ComponentType<ErrorsProviderContainerProps>;
     };
     /** Default ToastError customization (only used with default ToastError component) */
     toastErrorCustomization?: ToastErrorCustomization;
@@ -42,7 +53,14 @@ type ErrorsProviderCustomization = {
     toastCloseButton?: Omit<ToastCloseButtonProps, 'closeToast'>;
     /** Custom class name generators */
     classNames?: {
-        /** Function to generate container classes */
+        /**
+         * Returns the classes of the toasts, instead of the default ones.
+         *
+         * @param params - The error state.
+         * @param params.hasErrors - Whether the store has a connection or network switch error.
+         * @param params.errorType - `'wallet'`, `'switch'`, or `null` without error.
+         * @returns The classes.
+         */
         container?: (params: {
             hasErrors: boolean;
             errorType: 'wallet' | 'switch' | null;
@@ -50,7 +68,17 @@ type ErrorsProviderCustomization = {
     };
     /** Custom toast options generators */
     toastOptions?: {
-        /** Function to generate toast options */
+        /**
+         * Returns options of `toast.error` of `react-toastify`, merged over the default ones (`containerId`, `toastId`,
+         * `onClose`).
+         *
+         * @param params - The error to show.
+         * @param params.title - The toast title.
+         * @param params.rawError - The error.
+         * @param params.errorType - `'wallet'` or `'switch'`.
+         * @param params.isConnected - Whether a wallet is connected.
+         * @returns The toast options.
+         */
         error?: (params: {
             title: string;
             rawError: string | TuwaErrorState;
@@ -60,28 +88,65 @@ type ErrorsProviderCustomization = {
     };
     /** Custom logic handlers */
     handlers?: {
-        /** Custom error display logic */
+        /**
+         * Wraps the display of an error toast: call `originalHandler(title, rawError, errorKey)` to show it.
+         *
+         * @param originalHandler - Shows the toast (once per `errorKey`), after dismissing the previous one.
+         * @param params - The error to show.
+         * @param params.title - The toast title.
+         * @param params.rawError - The error.
+         * @param params.errorKey - Key of the error (from `errorHash`), used to show it only once.
+         * @param params.errorType - `'wallet'` or `'switch'`.
+         */
         showError?: (originalHandler: (title: string, rawError: string | TuwaErrorState, errorKey: string) => void, params: {
             title: string;
             rawError: string | TuwaErrorState;
             errorKey: string;
             errorType: 'wallet' | 'switch' | null;
         }) => void;
-        /** Custom error dismissal logic */
+        /**
+         * Wraps the dismissal of the error toasts: call `originalHandler()` to dismiss them.
+         *
+         * @param originalHandler - Dismisses the toasts of the container.
+         */
         dismissError?: (originalHandler: () => void) => void;
-        /** Custom copy complete handler */
+        /**
+         * Called after the copy button of a toast tried to copy the error. By default, logs the copied message in
+         * development.
+         *
+         * @param success - Whether the error was copied.
+         * @param rawError - The error.
+         * @param errorType - `'wallet'` or `'switch'`.
+         */
         onCopyComplete?: (success: boolean, rawError: string | TuwaErrorState, errorType: 'wallet' | 'switch' | null) => void;
     };
-    /** Custom error title generator - does NOT customize labels, just allows title modification */
+    /**
+     * Returns the toast title. It does not change the labels, only the title of this toast.
+     *
+     * @param defaultTitle - The label of the error type (`connectionError`, `errorWhenChainSwitching` or
+     * `somethingWentWrong`).
+     * @param params - The error.
+     * @param params.errorType - `'wallet'`, `'switch'`, or `null`.
+     * @returns The title.
+     */
     errorTitle?: (defaultTitle: string, params: {
         errorType: 'wallet' | 'switch' | null;
     }) => string;
-    /** Custom error hash generator for deduplication */
+    /**
+     * Returns the key used to show an error only once.
+     *
+     * @param defaultHash - The error type and the first 50 characters of the message, or `null` without error.
+     * @param params - The error.
+     * @param params.primaryError - The error of the store (`connectionError` first).
+     * @param params.errorType - `'wallet'`, `'switch'`, or `null`.
+     * @returns The key, or `null` to show nothing.
+     */
     errorHash?: (defaultHash: string | null, params: {
         primaryError: TuwaErrorState | null;
         errorType: 'wallet' | 'switch' | null;
     }) => string | null;
 };
+/** Props of {@link ErrorsProvider}. */
 interface ErrorsProviderProps {
     /** Custom container ID for toast notifications */
     containerId?: string;
@@ -95,39 +160,46 @@ interface ErrorsProviderProps {
     customization?: ErrorsProviderCustomization;
 }
 /**
- * A highly customizable error toast provider with extensive styling options and component replacement capabilities.
- * Provides comprehensive customization for appearance, behavior, and error handling logic while maintaining accessibility.
+ * Shows the connection and network switch errors of the Satellite Connect store (`connectionError`,
+ * `switchNetworkError`) as `react-toastify` toasts ({@link ToastError}) in its own `ToastContainer` (id
+ * `nova-connect-errors`, top center, closed after 7 seconds by default). Each error is shown once; the toasts are
+ * dismissed when a wallet connects without error. `NovaConnectProvider` renders it.
+ *
+ * @param props - See {@link ErrorsProviderProps}.
+ * @returns The toast container.
  */
 declare function ErrorsProvider({ containerId, position, autoClose, draggable, customization, }: ErrorsProviderProps): React.JSX.Element;
 declare namespace ErrorsProvider {
     var displayName: string;
 }
 
+/**
+ * Props for the {@link NovaConnectLabelsProvider} component.
+ */
 interface NovaConnectLabelsProviderProps {
-    /** An object containing the custom labels */
+    /** All labels (spread `defaultLabels` of `@tuwaio/nova-connect/i18n` to change only some) */
     labels: NovaConnectLabels;
     /** The child components to render */
     children: ReactNode;
 }
 /**
- * A React component that provides a custom set of labels to all child components.
- * Wrap your application or component tree with this provider to apply custom translations.
+ * Provides labels to the Nova Connect components below it. `NovaConnectProvider` already renders it with the `labels`
+ * prop merged into the defaults, so use it directly only to give a part of the tree other texts. In development it
+ * warns about missing basic labels.
  *
- * The provider uses React.memo optimization and validates labels in development mode.
+ * @param props - See {@link NovaConnectLabelsProviderProps}.
+ * @returns The labels context provider.
  *
  * @example
- * ```typescript
- * import { NovaConnectLabelsProvider } from './NovaConnectLabelsProvider';
- *
- * function App() {
- *   const customLabels = {
- *     connectWallet: 'Подключить кошелек',
- *     disconnect: 'Отключиться',
- *   };
+ * ```tsx
+ * import { NovaConnectLabelsProvider } from '@tuwaio/nova-connect';
+ * import { defaultLabels } from '@tuwaio/nova-connect/i18n';
+ * import type { ReactNode } from 'react';
  *
+ * export function CustomTexts({ children }: { children: ReactNode }) {
  *   return (
- *     <NovaConnectLabelsProvider labels={customLabels}>
- *       <YourApp />
+ *     <NovaConnectLabelsProvider labels={{ ...defaultLabels, connectWallet: 'Link wallet' }}>
+ *       {children}
  *     </NovaConnectLabelsProvider>
  *   );
  * }
@@ -139,22 +211,25 @@ declare namespace NovaConnectLabelsProvider {
 }
 
 /**
- * Props for custom NovaConnectLabelsProvider component
+ * Props for a custom labels provider (the default one is `NovaConnectLabelsProvider`).
  */
-type CustomLabelsProviderProps = {
+type NovaConnectProviderLabelsProviderProps = {
+    /** The final labels (after `labels.merge` and `labels.transform`) */
     labels?: Partial<NovaConnectLabels>;
+    /** The app */
     children: ReactNode;
 };
 /**
- * Props for custom ErrorsProvider component
+ * Props for a custom errors provider (the default one is `ErrorsProvider`).
  */
-type CustomErrorsProviderProps = {
+type NovaConnectProviderErrorsProviderProps = {
+    /** `customization.errors` */
     customization?: ErrorsProviderCustomization;
 };
 /**
  * Context data passed to custom provider components
  */
-type ProviderContext = {
+type NovaConnectProviderCustomizationContext = {
     /** Current wallet connection state */
     isConnected: boolean;
     /** Active wallet instance */
@@ -163,18 +238,25 @@ type ProviderContext = {
     connectionError: TuwaErrorState | undefined;
     /** All modal and UI states */
     modalStates: {
+        /** Whether the connect modal is open */
         isConnectModalOpen: boolean;
+        /** Whether the connected modal is open */
         isConnectedModalOpen: boolean;
+        /** Whether the desktop chain list is open */
         isChainsListOpen: boolean;
+        /** Whether the mobile chain dialog is open */
         isChainsListOpenMobile: boolean;
     };
     /** Current content types for modals */
     contentTypes: {
+        /** Screen of the connect modal */
         connectModal: ConnectContentType;
+        /** Screen of the connected modal */
         connectedModal: ConnectedContentType;
     };
     /** Button and transaction statuses */
     statuses: {
+        /** Transaction status of the connect button */
         connectedButton: ButtonTxStatus;
     };
 };
@@ -185,34 +267,66 @@ type NovaConnectProviderCustomization = {
     /** Custom components */
     components?: {
         /** Custom labels provider component */
-        LabelsProvider?: ComponentType<CustomLabelsProviderProps>;
+        LabelsProvider?: ComponentType<NovaConnectProviderLabelsProviderProps>;
         /** Custom errors provider component */
-        ErrorsProvider?: ComponentType<CustomErrorsProviderProps>;
+        ErrorsProvider?: ComponentType<NovaConnectProviderErrorsProviderProps>;
     };
     /** Labels customization and merging strategy */
     labels?: {
-        /** Custom labels merging function */
+        /**
+         * Merges the `labels` prop into the defaults, instead of a deep merge.
+         *
+         * @param defaultLabels - The English defaults.
+         * @param userLabels - The `labels` prop (an empty object without it).
+         * @returns The merged labels.
+         */
         merge?: (defaultLabels: NovaConnectLabels, userLabels: Partial<NovaConnectLabels>) => NovaConnectLabels;
-        /** Transform final merged labels before use */
-        transform?: (mergedLabels: NovaConnectLabels, context: ProviderContext) => NovaConnectLabels;
+        /**
+         * Transforms the merged labels before they are provided.
+         *
+         * @param mergedLabels - The merged labels.
+         * @param context - State of the provider.
+         * @returns The final labels.
+         */
+        transform?: (mergedLabels: NovaConnectLabels, context: NovaConnectProviderCustomizationContext) => NovaConnectLabels;
     };
     /** ErrorsProvider customization - passed through to ErrorsProvider */
     errors?: ErrorsProviderCustomization;
     /** Custom context value transformation */
     contextValue?: {
-        /** Transform context value before providing to children */
-        transform?: (defaultValue: NovaConnectProviderType, context: ProviderContext) => NovaConnectProviderType;
+        /**
+         * Transforms the value of the context before it is provided.
+         *
+         * @param defaultValue - The state of the provider.
+         * @param context - State of the provider for customization.
+         * @returns The context value.
+         */
+        transform?: (defaultValue: NovaConnectProviderType, context: NovaConnectProviderCustomizationContext) => NovaConnectProviderType;
     };
     /** Custom rendering logic */
     rendering?: {
-        /** Custom provider tree structure */
+        /**
+         * Returns the rendered tree, instead of the default one. Keep the elements inside the context provider (the
+         * default tree and `MainContent` include it).
+         *
+         * @param defaultTree - The default tree: the context provider with the SIWX watcher, the errors provider, the
+         * labels provider with the app, and the two modals.
+         * @param components - The parts of the tree.
+         * @param components.ErrorsProvider - The errors provider element.
+         * @param components.LabelsProvider - The labels provider element with the app.
+         * @param components.MainContent - The same tree as `defaultTree`.
+         * @param components.ConnectModal - The connect modal (an empty fragment without chains).
+         * @param components.ConnectedModal - The connected modal (an empty fragment without chains).
+         * @param context - State of the provider.
+         * @returns The tree to render.
+         */
         providerTree?: (defaultTree: ReactNode, components: {
             ErrorsProvider: ReactNode;
             LabelsProvider: ReactNode;
             MainContent: ReactNode;
             ConnectModal: ReactNode;
             ConnectedModal: ReactNode;
-        }, context: ProviderContext) => ReactNode;
+        }, context: NovaConnectProviderCustomizationContext) => ReactNode;
     };
     /** Modal customizations */
     modals?: {
@@ -223,71 +337,45 @@ type NovaConnectProviderCustomization = {
     };
 };
 /**
- * Extended props for NovaConnectProvider with full customization capabilities
+ * Props for the {@link NovaConnectProvider} component: `NovaConnectProviderProps` with `customization`.
  */
 interface NovaConnectProviderPropsWithCustomization extends NovaConnectProviderProps {
     /** Comprehensive customization options for the provider and its sub-components */
     customization?: NovaConnectProviderCustomization;
 }
 /**
- * Main NovaConnect provider component with comprehensive customization capabilities.
+ * The provider of Nova Connect. Place it inside `SatelliteConnectProvider` (from `@tuwaio/nova-connect/satellite`): it
+ * reads the Satellite store. It keeps the UI state of the modals (read it with `useNovaConnect`), provides the labels
+ * (the `labels` prop merged into the English defaults), shows connection and network switch errors as toasts
+ * (`ErrorsProvider`), signs in with SIWX when `siwx` is set (`NovaSiwxWatcher`), and renders the connect and connected
+ * modals when `appChains` or `solanaRPCUrls` is set.
  *
- * This provider manages wallet connection state, error handling, internationalization,
- * modal states, and renders the modal components centrally while offering extensive
- * customization options for all sub-components and behaviors.
+ * @param props - See {@link NovaConnectProviderPropsWithCustomization}.
+ * @returns The provider tree.
  *
- * Features:
- * - Complete wallet connection state management
- * - Centralized modal rendering and state management
- * - Customizable error handling through ErrorsProvider
- * - Flexible internationalization system
- * - Modal and UI state coordination
- * - Extensive customization API for all aspects
- * - Custom component replacement capabilities
- *
- * @example Basic usage
+ * @example
  * ```tsx
- * <NovaConnectProvider
- *   store={store}
- *   appChains={[mainnet, sepolia, polygon]} // Viem chains
- *   solanaRPCUrls={{
- *     'mainnet': 'https://api.mainnet-beta.solana.com'
- *   }}
- * >
- *   <App />
- * </NovaConnectProvider>
- * ```
+ * import { NovaConnectProvider } from '@tuwaio/nova-connect';
+ * import type { ReactNode } from 'react';
+ * import { mainnet, polygon } from 'viem/chains';
  *
- * @example With customization
- * ```tsx
- * <NovaConnectProvider
- *   labels={customLabels}
- *   appChains={appChains}
- *   solanaRPCUrls={solanaRPCUrls}
- *   transactionPool={txPool}
- *   pulsarAdapter={adapters}
- *   withImpersonated
- *   withBalance
- *   withChain
- *   customization={{
- *     errors: {
- *       position: 'bottom-right',
- *       autoClose: 5000,
- *     },
- *     modals: {
- *       connectModal: {
- *         classNames: {
- *           container: () => 'custom-modal-style'
- *         }
- *       }
- *     }
- *   }}
- * >
- *   <App />
- * </NovaConnectProvider>
+ * export function WalletUI({ children }: { children: ReactNode }) {
+ *   return (
+ *     <NovaConnectProvider
+ *       appChains={[mainnet, polygon]}
+ *       solanaRPCUrls={{ devnet: 'https://api.devnet.solana.com' }}
+ *       withBalance
+ *       withChain
+ *       legal={{ termsUrl: 'https://example.com/terms', privacyUrl: 'https://example.com/privacy' }}
+ *       customization={{
+ *         modals: { connectModal: { classNames: { title: () => 'custom-title' } } },
+ *       }}
+ *     >
+ *       {children}
+ *     </NovaConnectProvider>
+ *   );
+ * }
  * ```
- *
- * @param props - Provider configuration and customization options
  */
 declare function NovaConnectProvider({ labels, children, appChains, solanaRPCUrls, transactionPool, pulsarAdapter, withImpersonated, withBalance, withChain, popularConnectors, customConnectorGroups, legal, siwx, customization, pagination, }: NovaConnectProviderPropsWithCustomization): React.JSX.Element;
 declare namespace NovaConnectProvider {
@@ -295,546 +383,70 @@ declare namespace NovaConnectProvider {
 }
 
 /**
- * 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 = {
- *   connectorType: WalletType.EVM_METAMASK,
- *   appChains: [
- *     { id: 1, name: 'Ethereum' },
- *     { id: 137, name: 'Polygon' }
- *   ],
- *   chains: [1, 137] // Optional filter
- * };
- * ```
+ * Parameters of {@link getChainsListByConnectorType}.
  */
-interface GetChainsListParams extends InitialChains {
-    /** The wallet type to determine chain compatibility */
+interface GetChainsListByConnectorTypeParams extends InitialChains {
+    /** Connector type whose network is used, for example `evm:metamask` */
     connectorType: ConnectorType;
-    /** Optional array of specific chain identifiers to filter or validate */
+    /** Solana only: keeps the clusters of these chain identifiers (for example `solana:devnet`) */
     chains?: ChainIdentifierArray;
 }
 /**
- * Retrieves chain list for a specific connectorType 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 connectorType type and chain data
- * @returns Promise resolving to array of chain identifiers
- *
- * @example
- * ```typescript
- * // Get EVM chains for MetaMask
- * const evmChains = await getChainsListByConnectorType({
- *   connectorType: ConnectorType.EVM_METAMASK,
- *   appChains: [
- *     { id: 1, name: 'Ethereum' },
- *     { id: 137, name: 'Polygon' }
- *   ]
- * });
- * // Returns: [1, 137]
- *
- * // Get Solana clusters for Phantom
- * const solanaClusters = await getChainsListByConnectorType({
- *   connectorType: ConnectorType.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 getChainsListByConnectorType(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({
- *   connectorType: ConnectorType.EVM_METAMASK,
- *   appChains: evmConfiguration
- * });
- * ```
- *
- * @since 1.0.0
- */
-declare function getChainsListByConnectorTypeSync(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.
+ * Returns the chains of the app for the network of a connector type.
  *
- * Provides immediate validation results without triggering adapter loading.
- * Falls back to basic type checking if adapter isn't pre-loaded.
+ * - EVM: the IDs of `appChains` (`getEvmChains` of `@tuwaio/orbit-evm` when `@tuwaio/nova-connect/evm` is imported).
+ * - Solana: when `@tuwaio/nova-connect/solana` is imported, `getSolanaClusters` of `@tuwaio/orbit-solana`: the cluster
+ *   monikers of `solanaRPCUrls` (every cluster with a public RPC URL without it), filtered by `chains` when set.
+ *   Otherwise the keys of `solanaRPCUrls`.
  *
- * @param chains - Array of chain identifiers to validate
- * @returns True if chains are valid for Solana
+ * @param params - See {@link GetChainsListByConnectorTypeParams}.
+ * @returns The chain IDs or cluster monikers (empty without `connectorType`, with a warning).
  *
  * @example
- * ```typescript
- * const isSolana = isSolanaChainListSync(['mainnet-beta', 'devnet']); // true
+ * ```ts
+ * import { getChainsListByConnectorType } from '@tuwaio/nova-connect';
+ * import { mainnet, polygon } from 'viem/chains';
+ *
+ * getChainsListByConnectorType({ connectorType: 'evm:metamask', appChains: [mainnet, polygon] }); // [1, 137]
+ * getChainsListByConnectorType({
+ *   connectorType: 'solana:phantom',
+ *   solanaRPCUrls: { devnet: 'https://api.devnet.solana.com' },
+ * }); // ['devnet']
  * ```
- *
- * @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[]>;
+declare function getChainsListByConnectorType(params: GetChainsListByConnectorTypeParams): (string | number)[];
 /**
- * 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
+ * Checks whether a chain list has only EVM chain IDs (numbers), with `isEvmChainList` of `@tuwaio/orbit-evm` when
+ * `@tuwaio/nova-connect/evm` is imported.
  *
- * // Use for form validation
- * if (await isValidSolanaCluster(userInput)) {
- *   // Proceed with connection
- * } else {
- *   // Show error message
- * }
- * ```
- *
- * @since 1.0.0
+ * @param chains - Chain identifiers.
+ * @returns `true` when the list is not empty and has only numbers.
  */
-declare function isValidSolanaCluster$1(cluster: string): Promise<boolean>;
+declare function isEvmChainList(chains: (string | number)[]): 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.
+ * Checks whether a chain list has only Solana cluster monikers (strings), with `isSolanaChainList` of
+ * `@tuwaio/orbit-solana` when `@tuwaio/nova-connect/solana` is imported.
  *
- * 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
+ * @param chains - Chain identifiers.
+ * @returns `true` when the list is not empty and has only strings.
  */
-declare function getWalletChains(activeWallet: any): (string | number)[] | undefined;
+declare function isSolanaChainList(chains: (string | number)[]): boolean;
 /**
- * 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.
+ * Reads `connectedWallet.chains` of a connection (the Wallet Standard wallet of a Solana connection).
  *
- * 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
+ * @param connection - A connection, or any other value.
+ * @returns The chains, or `undefined` when the value has no such array.
  *
  * @example
- * ```typescript
- * // During app initialization
- * export async function initializeApp() {
- *   // Preload common adapters
- *   await preloadChainAdapters([OrbitAdapter.EVM, OrbitAdapter.SOLANA]);
+ * ```ts
+ * import { getWalletChains } from '@tuwaio/nova-connect';
  *
- *   // 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
+ * getWalletChains({ connectedWallet: { chains: ['solana:mainnet', 'solana:devnet'] } });
+ * // ['solana:mainnet', 'solana:devnet']
+ * getWalletChains({}); // undefined
  * ```
- *
- * @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 Promise resolving to array of chain identifiers (numbers for EVM, strings for Solana)
-     *
-     * @example
-     * ```typescript
-     * // EVM chains
-     * const evmChains = await adapter.getChains([
-     *   { id: 1, name: 'Ethereum' },
-     *   { id: 56, name: 'BSC' }
-     * ]);
-     * // Returns: [1, 56]
-     *
-     * // Solana clusters
-     * const solanaClusters = await 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 Promise resolving to array of available cluster names
-     * @optional This method is only available on Solana adapters
-     *
-     * @example
-     * ```typescript
-     * const solanaAdapter = await createSolanaAdapter();
-     * const clusters = await 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 Promise resolving to 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 = await solanaAdapter.isValidCluster?.('mainnet-beta'); // true
-     * const isInvalid = await 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.
- *
- * @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')
- * };
- * ```
- */
-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;
-}
+declare function getWalletChains(connection: unknown): ChainIdentifierArray | undefined;
 
 /**
  * Gets the appropriate chain ID for connecting based on the selected adapter.
@@ -850,302 +462,82 @@ declare function getConnectChainId({ selectedAdapter, appChains, solanaRPCUrls,
     selectedAdapter: OrbitAdapter;
 } & InitialChains): number | string;
 /**
- * Helper to get all available chain IDs for an adapter
+ * Returns the chains of the app for a network.
+ *
+ * @param params - The network and the chains of the app.
+ * @param params.selectedAdapter - The network.
+ * @returns The IDs of `appChains` (EVM) or the cluster monikers of `solanaRPCUrls` (Solana); the default chain of the
+ * network (Ethereum Mainnet, Solana Mainnet) when the list is empty.
  */
 declare function getAvailableChainIds({ selectedAdapter, appChains, solanaRPCUrls, }: {
     selectedAdapter: OrbitAdapter;
 } & InitialChains): Array<number | string>;
 
+/**
+ * A wallet with its connectors on each network, returned by {@link getGroupedConnectors}.
+ */
 interface GroupedConnector {
+    /** Name of the first connector of the wallet */
     name: string;
+    /** Icon of the first connector that has one (a data URL or URL) */
     icon?: string;
+    /** Adapters on which the wallet has a connector */
     adapters: OrbitAdapter[];
+    /** The connectors of the wallet, each with its adapter */
     connectors: (Connector & {
+        /** Adapter of the connector */
         adapter: OrbitAdapter;
     })[];
 }
+/**
+ * Parameters of {@link getGroupedConnectors}.
+ */
 interface GetGroupedConnectorsParams {
+    /** Connectors by adapter, as `getConnectors()` of the Satellite store returns them */
     connectors: Partial<Record<OrbitAdapter, Connector[]>>;
+    /** Names of connectors to leave out, compared after `formatConnectorName` (default: `['injected']`) */
     excludeConnectors?: string[];
 }
 /**
- * Groups wallet connectors by their formatted names across different adapters.
- * Filters out specified excluded connectors (like 'injected' wallets).
+ * Groups connectors of all adapters by wallet: connectors whose names give the same `formatConnectorName` (from
+ * `@tuwaio/orbit-core`) belong to one wallet. Connectors without a name are skipped.
+ *
+ * @param params - See {@link GetGroupedConnectorsParams} (default: no connectors).
+ * @returns The wallets sorted by name (case-insensitive).
  */
 declare function getGroupedConnectors({ connectors, excludeConnectors }?: GetGroupedConnectorsParams): GroupedConnector[];
 /**
- * Quick helper to check if connectors are available
+ * Checks whether any adapter has at least one connector.
+ *
+ * @param connectors - Connectors by adapter.
+ * @returns `true` when one of the arrays is not empty.
  */
 declare function hasAvailableConnectors(connectors: Partial<Record<OrbitAdapter, Connector[]>>): boolean;
 
+/**
+ * Parameters of {@link getFilteredConnectors}.
+ */
 interface GetFilteredConnectorsParams {
+    /** Connectors by adapter, as `getConnectors()` of the Satellite store returns them */
     connectors: Partial<Record<OrbitAdapter, Connector[]>>;
+    /** Keeps only the wallets (and their connectors) of this adapter */
     selectedAdapter?: OrbitAdapter;
 }
 /**
- * Filters grouped connectors by the selected adapter.
- * Returns all connectors if no adapter is selected, or only connectors
- * that support the specified adapter if one is provided.
+ * Groups the connectors by wallet with {@link getGroupedConnectors} (without the generic `injected` connector) and
+ * keeps the wallets of the selected adapter, with only the connectors of that adapter.
  *
- * @param params Configuration object with connectors and optional adapter filter
- * @returns Filtered array of grouped connectors
+ * @param params - See {@link GetFilteredConnectorsParams}.
+ * @returns The wallets sorted by name (all of them when `selectedAdapter` is not set).
  */
 declare function getFilteredConnectors({ connectors, selectedAdapter, }: GetFilteredConnectorsParams): GroupedConnector[];
 /**
- * Quick helper to check if any connectors exist for an adapter
- */
-declare function hasConnectorsForAdapter(connectors: Partial<Record<OrbitAdapter, Connector[]>>, adapter: OrbitAdapter): boolean;
-
-/**
- * @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.
+ * Checks whether an adapter has at least one connector.
  *
- * 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 { getChainsListByConnectorType, 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.
+ * @param connectors - Connectors by adapter.
+ * @param adapter - The adapter to check.
+ * @returns `true` when `connectors[adapter]` is a non-empty array.
  */
+declare function hasConnectorsForAdapter(connectors: Partial<Record<OrbitAdapter, Connector[]>>, adapter: OrbitAdapter): boolean;
 
-/**
- * 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 { type AdapterInfo, type AdapterLoadStatus, type BlockchainUtilities, type BlockchainUtilityResult, ButtonTxStatus, type ChainAdapter, ConnectContentType, ConnectedContentType, ErrorsProvider, type ErrorsProviderCustomization, type ErrorsProviderProps, type GroupedConnector, InitialChains, type InitializationResult, NovaConnectLabelsProvider, NovaConnectProvider, type NovaConnectProviderCustomization, NovaConnectProviderProps, type NovaConnectProviderPropsWithCustomization, NovaConnectProviderType, getAdapterStatus, getAllAdaptersStatus, getAvailableChainIds, getAvailableSolanaClusters, getAvailableSolanaClusters$1 as getAvailableSolanaClustersAsync, getBlockchainUtilities, getChainsListByConnectorTypeSync as getChainsListByConnectorType, getChainsListByConnectorType as getChainsListByConnectorTypeAsync, getChainsListByConnectorTypeSync, getConnectChainId, getEvmUtils, getFilteredConnectors, getGroupedConnectors, getSolanaUtils, getWalletChains, hasAvailableConnectors, hasConnectorsForAdapter, initializeBlockchainSupport, isAdapterSupported, isEvmChainListSync as isEvmChainList, isEvmChainList as isEvmChainListAsync, isEvmChainListSync, isSolanaChainListSync as isSolanaChainList, isSolanaChainList as isSolanaChainListAsync, isSolanaChainListSync, isValidSolanaCluster, isValidSolanaCluster$1 as isValidSolanaClusterAsync, preloadChainAdapters };
+export { ButtonTxStatus, ConnectContentType, ConnectedContentType, ErrorsProvider, type ErrorsProviderContainerProps, type ErrorsProviderCustomization, type ErrorsProviderProps, type ErrorsProviderToastErrorProps, type GetChainsListByConnectorTypeParams, type GetFilteredConnectorsParams, type GetGroupedConnectorsParams, type GroupedConnector, InitialChains, NovaConnectLabelsProvider, type NovaConnectLabelsProviderProps, NovaConnectProvider, type NovaConnectProviderCustomization, type NovaConnectProviderCustomizationContext, type NovaConnectProviderErrorsProviderProps, type NovaConnectProviderLabelsProviderProps, NovaConnectProviderProps, type NovaConnectProviderPropsWithCustomization, NovaConnectProviderType, getAvailableChainIds, getChainsListByConnectorType, getConnectChainId, getFilteredConnectors, getGroupedConnectors, getWalletChains, hasAvailableConnectors, hasConnectorsForAdapter, isEvmChainList, isSolanaChainList };