@sodax/wallet-sdk-react 1.5.6-beta → 2.0.0-rc.1

package/dist/index.d.ts

@@ -1,1579 +1,849 @@
-import { ChainId, ChainType, XToken, IBitcoinWalletProvider, BtcWalletAddressType, RpcConfig, IEvmWalletProvider, ISuiWalletProvider, IIconWalletProvider, IInjectiveWalletProvider, IStellarWalletProvider, ISolanaWalletProvider, INearWalletProvider, IStacksWalletProvider } from '@sodax/types';
-export { BtcWalletAddressType } from '@sodax/types';
-import { AddressPurpose } from 'sats-connect';
-import * as wagmi from 'wagmi';
-import { State, Config, Connector } from 'wagmi';
-import * as viem_chains from 'viem/chains';
-import * as wagmi_chains from 'wagmi/chains';
-import * as viem from 'viem';
-import React from 'react';
-import { IconService } from 'icon-sdk-js';
-import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi } from '@injectivelabs/sdk-ts';
-import { MsgBroadcaster } from '@injectivelabs/wallet-core';
-import { WalletStrategy } from '@injectivelabs/wallet-strategy';
-import { Wallet } from '@injectivelabs/wallet-base';
-import { Connection } from '@solana/web3.js';
-import { WalletContextState } from '@solana/wallet-adapter-react';
-import { StellarWalletsKit } from '@creit.tech/stellar-wallets-kit';
-import * as StellarSdk from '@stellar/stellar-sdk';
-import { SorobanRpc, Transaction, Memo, MemoType, Operation, FeeBumpTransaction } from '@stellar/stellar-sdk';
-import { StacksNetwork } from '@stacks/network';
-import { StacksProvider } from '@stacks/connect';
-import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
-import * as immer from 'immer';
-import * as zustand_middleware from 'zustand/middleware';
-import * as zustand from 'zustand';
+import { SpokeChainKey, GetChainType, ChainType, ChainKey, EvmChainKey, XToken, GetWalletProviderType } from '@sodax/types';
+export { IWalletProvider } from '@sodax/types';
+import { X as XAccount, I as IXConnector, a as XConnection, b as XService, c as XConnector } from './XConnector-B9YQTVJ4.js';
+export { d as IXService } from './XConnector-B9YQTVJ4.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { S as SodaxWalletConfig, C as ChainEntry, W as WalletDefaultsByKey, E as EvmChainEntry } from './config-OlnzyEUE.js';
+export { B as BitcoinChainEntry, o as BitcoinTypeConfig, i as ChainMeta, k as ChainTypeConfig, j as ChainTypeOf, f as EvmAdapterFields, l as EvmTypeConfig, I as IconChainEntry, r as IconTypeConfig, d as InjectiveChainEntry, q as InjectiveTypeConfig, N as NearChainEntry, s as NearTypeConfig, g as SolanaAdapterFields, a as SolanaChainEntry, m as SolanaTypeConfig, e as StacksChainEntry, t as StacksTypeConfig, c as StellarChainEntry, p as StellarTypeConfig, h as SuiAdapterFields, b as SuiChainEntry, n as SuiTypeConfig } from './config-OlnzyEUE.js';
+import { UseMutationResult } from '@tanstack/react-query';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { EvmWalletDefaults } from '@sodax/wallet-sdk-core';
+import 'wagmi';
+import 'wagmi/connectors';
 
-declare function getXChainType(xChainId: ChainId | undefined): ChainType | undefined;
+/**
+ * `GetChainType` only accepts `SpokeChainKey | ChainType` — it cannot be given `undefined`.
+ * When the generic may include `undefined`, narrow with `Exclude` and only union `undefined` on the result.
+ */
+type GetXChainReturnType<K extends SpokeChainKey | undefined> = K extends SpokeChainKey ? GetChainType<K> : K extends undefined ? undefined : ChainType | undefined;
+declare function getXChainType<K extends SpokeChainKey>(xChainId: K | undefined): GetXChainReturnType<K | undefined>;
+
+type ChainActions = {
+    connect: (xConnectorId: string) => Promise<XAccount | undefined>;
+    disconnect: () => Promise<void>;
+    getConnectors: () => IXConnector[];
+    getConnection: () => XConnection | undefined;
+    signMessage?: (message: string) => Promise<string>;
+};
+type ChainActionsRegistry = Partial<Record<ChainType, ChainActions>>;
 
-type XAccount = {
-    address: string | undefined;
-    xChainType: ChainType | undefined;
-    publicKey?: string;
+declare function getXService(xChainType: ChainType): XService;
+
+declare const WalletConfigProvider: react.Provider<SodaxWalletConfig | null>;
+declare function useWalletConfig(): SodaxWalletConfig;
+/** A chain type is "enabled" only when its slot is present in SodaxWalletConfig. */
+declare function useIsChainEnabled(chainType: ChainType): boolean;
+/** See {@link useIsChainEnabled} for the "enabled" semantic. */
+declare function useEnabledChainTypes(): ChainType[];
+
+type SortConnectorsOptions = {
+    /** Connector IDs to prioritize. Earlier entries win. */
+    preferred?: readonly string[];
 };
-type XConnection = {
-    xAccount: XAccount;
-    xConnectorId: string;
+/**
+ * Stable sort of connectors for display. Ranking (highest first):
+ *   1. Appears in `preferred[]` — earlier entries rank higher
+ *   2. `connector.isInstalled === true`
+ *   3. Original order (stable)
+ *
+ * Pure function — does not subscribe or read window.
+ */
+declare function sortConnectors<T extends IXConnector>(connectors: readonly T[], options?: SortConnectorsOptions): T[];
+
+/**
+ * Extract `defaults` from a chain entry. Returns undefined when the entry is
+ * missing, or for Stacks's preset-name string variant (no `defaults` slot).
+ */
+declare function getEntryDefaults<K extends ChainKey>(entry: ChainEntry<K> | undefined): WalletDefaultsByKey<K> | undefined;
+/**
+ * Extract `rpcUrl` from a chain entry. Use for chains whose underlying factory
+ * expects a bare URL string (EVM/Solana/Sui/Icon/Near). Returns undefined for
+ * missing entries and for non-rpcUrl forms (Stacks preset name, object entries
+ * lacking the field) — downstream falls back to a public default.
+ */
+declare function getRpcUrl<K extends ChainKey>(entry: ChainEntry<K> | undefined): string | undefined;
+/**
+ * Resolve EVM wallet provider defaults for the chain currently active on a
+ * wagmi-supplied client. Used by `EvmHydrator` so the provider re-instantiates
+ * with the right defaults when wagmi swaps clients on chain switch.
+ *
+ * `getEvmChainKeyByChainId` lives in `@sodax/types` (alongside `baseChainInfo`,
+ * the data source); this helper composes it with the `SodaxWalletConfig.EVM.chains`
+ * lookup, which is React-layer concern.
+ */
+declare function resolveEvmDefaults(activeChainId: number | undefined, evmChains: Partial<Record<EvmChainKey, EvmChainEntry>> | undefined): EvmWalletDefaults | undefined;
+
+declare const isNativeToken: (xToken: XToken) => boolean;
+declare const getWagmiChainId: (xChainId: SpokeChainKey) => number;
+
+type UseXAccountOptions = {
+    xChainId: SpokeChainKey;
+    xChainType?: never;
+} | {
+    xChainType: ChainType;
+    xChainId?: never;
 };
-type CurrencyKey = string;
-declare enum WalletId {
-    METAMASK = "metamask",
-    HANA = "hana",
-    PHANTOM = "phantom",
-    SUI = "sui",
-    KEPLR = "keplr"
-}
+/**
+ * Returns the connected `XAccount` for a chain family.
+ *
+ * Pass either `xChainId` (a `SpokeChainKey` — auto-resolved to its family) or
+ * `xChainType` (a `ChainType` directly), never both. EVM is family-level — wagmi
+ * maintains a single connection across every configured EVM network.
+ *
+ * Always returns a populated object, never `undefined`. When no wallet is connected,
+ * `address` is `undefined` but `xChainType` is filled — consumers can render
+ * `account.address ?? <ConnectCta />` without null-checking the wrapper.
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONNECT_FLOW.md#read-connected-account-state | Connect Flow — Read state}
+ */
+declare function useXAccount({ xChainId, xChainType }: UseXAccountOptions): XAccount;
 
 /**
- * Base class for wallet provider connectors that handles connection management and wallet interactions
- *
- * @abstract
- * @class XConnector
- * @property {ChainType} xChainType - The blockchain type this connector supports
- * @property {string} name - Display name of the wallet provider
- * @property {string} _id - Unique identifier for the connector
- * @property {string | undefined} _icon - Optional icon URL for the wallet provider
+ * Returns connected accounts for every enabled chain type, keyed by `ChainType`.
+ *
+ * Each entry is always populated — disconnected chains have `address: undefined`,
+ * mirroring `useXAccount`'s shape. Iterates `enabledChains` so the result reflects
+ * exactly the slots present in `SodaxWalletProvider` config.
+ *
+ * Useful for "manage connections" panels and multi-chain status badges. For an
+ * enriched view with connector metadata (name, icon), use `useConnectedChains` —
+ * which also exposes a hydration `status` flag to gate first-paint UI.
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONNECT_FLOW.md#read-connected-account-state | Connect Flow — Read state}
  */
-declare abstract class XConnector {
-    /** The blockchain type this connector supports */
-    readonly xChainType: ChainType;
-    /** Display name of the wallet provider */
-    readonly name: string;
-    /** Unique identifier for the connector */
-    private readonly _id;
-    /** Optional icon URL for the wallet provider */
-    private readonly _icon?;
-    constructor(xChainType: ChainType, name: string, id: string);
-    /**
-     * Connects to the wallet provider
-     * @returns Promise resolving to the connected account, or undefined if connection fails
-     */
-    abstract connect(): Promise<XAccount | undefined>;
-    /**
-     * Disconnects from the wallet provider
-     */
-    abstract disconnect(): Promise<void>;
-    /** Get the unique identifier for this connector */
-    get id(): string;
-    /** Get the optional icon URL for this wallet provider */
-    get icon(): string | undefined;
-}
+declare function useXAccounts(): Partial<Record<"ICON" | "EVM" | "INJECTIVE" | "SUI" | "STELLAR" | "SOLANA" | "STACKS" | "NEAR" | "BITCOIN", XAccount>>;
 
 /**
- * Abstract base class for blockchain service implementations.
+ * React Query mutation that connects a wallet via the supplied `IXConnector`.
+ *
+ * Pass an `IXConnector` (from `useXConnectors` / `useXConnectorsByChain`) to
+ * `mutate` / `mutateAsync`. The hook delegates to the chain's `ChainActions.connect()`
+ * and writes the resulting connection state into the store on success.
  *
- * The XService class serves as a foundation for implementing blockchain-specific services
- * in a multi-chain environment. It provides a standardized interface for:
- * 1. Managing wallet connectors for different blockchain types
- * 2. Querying token balances across different chains
+ * **Provider-managed chains caveat** (EVM/Solana/Sui): the mutation resolves with
+ * `undefined` because connection state is set reactively by the chain's Hydrator
+ * after the native SDK reports `connected`. Read the resolved account via
+ * `useXAccount` / `useXConnection`, not the mutation's return value.
  *
- * Each blockchain implementation (e.g., Solana, EVM chains) extends this class
- * to provide chain-specific functionality while maintaining a consistent interface.
+ * **Non-provider chains** (Bitcoin, ICON, Injective, Stellar, NEAR, Stacks) return
+ * the resolved `XAccount` directly. Code defensively if your component supports
+ * both — `useXAccount` works for both cases.
  *
- * @abstract
- * @class XService
- * @property {ChainType} xChainType - The blockchain type this service handles (e.g., 'SOLANA', 'EVM')
- * @property {XConnector[]} xConnectors - Available wallet connectors for this chain
+ * Throws `Error('Chain "<X>" is not enabled or ChainActions not registered')` when
+ * the connector's chain type isn't mounted in `SodaxWalletProvider` config.
  *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONNECT_FLOW.md#connect-a-wallet | Connect Flow — Connect}
  */
-declare abstract class XService {
-    /** The blockchain type this service handles */
-    readonly xChainType: ChainType;
-    /** Available wallet connectors for this chain */
-    private xConnectors;
-    constructor(xChainType: ChainType);
-    /**
-     * Gets the balance of a specific token for an address
-     * @param address The wallet address to check
-     * @param xToken The token to get the balance for
-     * @returns Promise resolving to the token balance as a bigint
-     */
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-    /**
-     * Gets balances for multiple tokens for an address
-     * @param address The wallet address to check
-     * @param xTokens Array of tokens to get balances for
-     * @returns Promise resolving to object mapping token addresses to balances
-     */
-    getBalances(address: string | undefined, xTokens: readonly XToken[]): Promise<Record<string, bigint>>;
-    /**
-     * Gets all available connectors for this chain
-     */
-    getXConnectors(): XConnector[];
-    /**
-     * Sets the available connectors for this chain
-     */
-    setXConnectors(xConnectors: XConnector[]): void;
-    /**
-     * Gets a specific connector by its ID
-     * @param xConnectorId The connector ID to look up
-     * @returns The matching connector or undefined if not found
-     */
-    getXConnectorById(xConnectorId: string): XConnector | undefined;
-}
+declare function useXConnect(): UseMutationResult<XAccount | undefined, Error, IXConnector>;
 
-declare function getXService(xChainType: ChainType): XService;
+type UseXConnectionOptions = {
+    xChainType?: ChainType;
+};
+/**
+ * Returns the active `XConnection` for a chain type — `{ xAccount, xConnectorId }` —
+ * or `undefined` when no wallet is connected.
+ *
+ * Use this when you need the connector identity (e.g. to label a disconnect button
+ * with the wallet name or icon). For just the address, prefer `useXAccount`, which
+ * always returns a populated object and saves a null check.
+ *
+ * Returns `undefined` when `xChainType` is omitted — the field is optional to
+ * accommodate consumers that branch on chain availability.
+ */
+declare function useXConnection({ xChainType }?: UseXConnectionOptions): XConnection | undefined;
 
-declare const isNativeToken: (xToken: XToken) => boolean;
-declare const getWagmiChainId: (xChainId: ChainId) => number;
+/**
+ * Returns active wallet connections keyed by `ChainType`.
+ *
+ * Only chains with a connected wallet have entries — disconnected chains are absent
+ * from the map (unlike `useXAccounts`, which always populates every enabled chain).
+ *
+ * The returned object reference is the persisted `xConnections` slice — stable
+ * across re-renders that don't change connection state. Mutate via `useXConnect` /
+ * `useXDisconnect`, never directly.
+ */
+declare function useXConnections(): Partial<Record<ChainType, XConnection>>;
+
+type UseXConnectorsOptions = {
+    xChainType?: ChainType;
+};
+/**
+ * Returns available wallet connectors for a specific chain type, with enriched
+ * metadata (`isInstalled`, `installUrl`, `icon`).
+ *
+ * Each `connector.isInstalled` reads `window.*` at access time — no extra subscription
+ * is installed. Components receive fresh values through normal React render triggers
+ * (store updates, parent re-renders).
+ *
+ * Returns `[]` when the chain isn't enabled in `SodaxWalletProvider` config and logs a
+ * one-time warning per chain to help debug missing connector lists. For multi-chain
+ * pickers, prefer `useXConnectorsByChain` which avoids the warning per chain.
+ *
+ * Pair with `sortConnectors(connectors, { preferred })` to rank installed/preferred wallets
+ * first. `preferred` matches by exact `connector.id` — for substring/case-insensitive matching,
+ * use `useIsWalletInstalled`.
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONNECT_FLOW.md#discover-connectors | Connect Flow — Discover}
+ */
+declare function useXConnectors({ xChainType }?: UseXConnectorsOptions): IXConnector[];
 
-declare class BitcoinXService extends XService {
-    private static instance;
-    private rpcUrl;
-    private constructor();
-    static getInstance(rpcUrl?: string): BitcoinXService;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-}
+/**
+ * Returns the connector list for every enabled chain type, grouped by `ChainType`.
+ *
+ * Used for multi-chain wallet pickers (e.g. listing every available wallet across
+ * EVM, Solana, Bitcoin in one render). For a single chain, prefer `useXConnectors`
+ * which also emits a one-time warning if the chain isn't enabled.
+ *
+ * Each connector's `isInstalled` reads `window.*` at access time — values stay
+ * fresh through normal React render triggers.
+ */
+declare function useXConnectorsByChain(): Partial<Record<ChainType, IXConnector[]>>;
 
 /**
- * Abstract base class for Bitcoin wallet connectors.
- * Subclasses implement wallet-specific connection logic (Unisat, Xverse, OKX).
+ * Either `connectors`, `chainType`, or both. The union prevents an empty
+ * `{}` at the type level — the hook must narrow at least one axis so the
+ * return value has a meaningful interpretation (not "is any wallet installed
+ * anywhere", which is rarely the intent).
  */
-declare abstract class BitcoinXConnector extends XConnector {
-    constructor(name: string, id: string);
-    getXService(): BitcoinXService;
-    abstract connect(): Promise<XAccount | undefined>;
-    abstract disconnect(): Promise<void>;
+type UseIsWalletInstalledOptions = {
     /**
-     * Returns an IBitcoinWalletProvider instance after connecting.
-     * Used by useSpokeProvider to build BitcoinSpokeProvider.
+     * Wallet brand identifiers (e.g. `'hana'`, `'phantom'`). Matched via
+     * case-insensitive substring against `connector.id` and `connector.name` —
+     * see {@link matchesConnectorIdentifier}. Returns `true` if ANY identifier
+     * matches an installed connector. Mirrors the `connectors` parameter of
+     * `useBatchConnect` / `useBatchDisconnect`.
      */
-    abstract getWalletProvider(): IBitcoinWalletProvider | undefined;
+    connectors: readonly string[];
+    chainType?: ChainType;
+} | {
+    connectors?: readonly string[];
+    /** Restrict the scan to a single chain. */
+    chainType: ChainType;
+};
+/**
+ * True when at least one connector across the configured chains is installed
+ * AND matches the supplied filters. `connectors` and `chainType` AND together;
+ * at least one of them must be supplied (enforced at the type level).
+ *
+ * @example
+ * // Single wallet across every chain
+ * const isHanaInstalled = useIsWalletInstalled({ connectors: ['hana'] });
+ *
+ * @example
+ * // Any of these wallets
+ * const hasMultiChainWallet = useIsWalletInstalled({ connectors: ['hana', 'okx', 'phantom'] });
+ *
+ * @example
+ * // Any wallet on a specific chain
+ * const hasBitcoin = useIsWalletInstalled({ chainType: 'BITCOIN' });
+ *
+ * @example
+ * // AND — Hana specifically on EVM
+ * const hanaOnEvm = useIsWalletInstalled({ connectors: ['hana'], chainType: 'EVM' });
+ */
+declare function useIsWalletInstalled(options: UseIsWalletInstalledOptions): boolean;
+
+type ChainGroup = {
+    chainType: ChainType;
+    /** All SpokeChainKeys that share this ChainType — e.g. every EVM network for `chainType: 'EVM'`. */
+    chainIds: readonly SpokeChainKey[];
+    displayName: string;
+    /** Icon URL from chainRegistry. `undefined` when SDK doesn't ship a default — consumer provides. */
+    iconUrl: string | undefined;
+    isConnected: boolean;
+    account: XAccount | undefined;
+    connectorId: string | undefined;
+};
+type UseChainGroupsOptions = {
     /**
-     * Recreates a walletProvider from the browser extension window object
-     * and stored xAccount data (no connect() call, no popup).
-     * Used to restore provider after page reload without requiring reconnect.
+     * Display order by `chainType`. Chains not listed fall to the bottom,
+     * sorted alphabetically among themselves. Omit to follow the insertion
+     * order of `enabledChains` (driven by `SodaxWalletProvider` config).
      */
-    abstract recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
-}
-
-interface UnisatWallet {
-    getAccounts(): Promise<string[]>;
-    getPublicKey(): Promise<string>;
-    signPsbt(psbtHex: string, options?: {
-        autoFinalized?: boolean;
-    }): Promise<string>;
-    signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
-    requestAccounts(): Promise<string[]>;
-    sendBitcoin(address: string, satoshis: number): Promise<string>;
-}
-declare global {
-    interface Window {
-        unisat?: UnisatWallet;
-    }
-}
-declare class UnisatXConnector extends BitcoinXConnector {
-    private walletProvider;
-    constructor();
-    static isAvailable(): boolean;
-    get icon(): string;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    getWalletProvider(): IBitcoinWalletProvider | undefined;
-    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
-}
-
-declare class XverseXConnector extends BitcoinXConnector {
-    private walletProvider;
-    /** Address purpose used when connecting. Taproot (Ordinals) by default to match Radfi. */
-    addressPurpose: AddressPurpose;
-    constructor();
-    /** Set address purpose and persist to localStorage. */
-    setAddressPurpose(type: BtcWalletAddressType): void;
-    static isAvailable(): boolean;
-    get icon(): string;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    getWalletProvider(): IBitcoinWalletProvider | undefined;
-    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
-}
-
-interface OKXBitcoinWallet {
-    getAccounts(): Promise<string[]>;
-    getPublicKey(): Promise<string>;
-    signPsbt(psbtHex: string, options?: {
-        autoFinalized?: boolean;
-    }): Promise<string>;
-    signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
-    connect(): Promise<{
-        address: string;
-        publicKey: string;
-    }>;
-    sendBitcoin(toAddress: string, satoshis: number): Promise<string>;
-}
-declare global {
-    interface Window {
-        okxwallet?: {
-            bitcoin?: OKXBitcoinWallet;
-        };
-    }
-}
-declare class OKXXConnector extends BitcoinXConnector {
-    private walletProvider;
-    constructor();
-    static isAvailable(): boolean;
-    get icon(): string;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    getWalletProvider(): IBitcoinWalletProvider | undefined;
-    recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
-}
-
+    order?: readonly ChainType[];
+};
 /**
- * Hook to return available Bitcoin wallet connectors from the globally registered xService.
+ * Returns one `ChainGroup` per enabled chain type. EVM collapses to a single
+ * group covering every EVM network via `chainIds`. Use for rendering modal
+ * chain-pickers.
+ *
+ * @example
+ * const groups = useChainGroups();
+ * return groups.map(g => (
+ *   <button key={g.chainType}>
+ *     {g.iconUrl && <img src={g.iconUrl} alt="" />}
+ *     {g.displayName}
+ *     {g.isConnected && <Badge>Connected</Badge>}
+ *   </button>
+ * ));
+ *
+ * @example
+ * // Deterministic display order — useful when the chain picker must render
+ * // hub-first regardless of enabledChains insertion order.
+ * const groups = useChainGroups({ order: ['EVM', 'ICON', 'SOLANA'] });
  */
-declare function useBitcoinXConnectors(): BitcoinXConnector[];
-
-type WagmiOptions = {
-    reconnectOnMount?: boolean;
-    ssr?: boolean;
+declare function useChainGroups({ order }?: UseChainGroupsOptions): ChainGroup[];
+
+type ConnectedChain = {
+    chainType: ChainType;
+    account: XAccount;
+    connectorId: string;
+    connectorName: string | undefined;
+    connectorIcon: string | undefined;
 };
-type SodaxWalletProviderOptions = {
-    wagmi?: WagmiOptions;
-    solana?: {
-        autoConnect?: boolean;
-    };
-    sui?: {
-        autoConnect?: boolean;
-    };
+type UseConnectedChainsResult = {
+    /** One entry per chain currently holding a connected account. */
+    chains: ConnectedChain[];
+    /** Number of connected chains. */
+    total: number;
+    /**
+     * `'loading'` until the store rehydrates from localStorage. Gate UI that
+     * switches visibly on connection state (e.g. `total >= 1 ? Connected : Cta`)
+     * with this flag to avoid flicker on reload.
+     */
+    status: 'loading' | 'ready';
 };
-type SodaxWalletProviderProps = {
-    children: React.ReactNode;
-    rpcConfig: RpcConfig;
-    options?: SodaxWalletProviderOptions;
-    initialState?: State;
+type UseConnectedChainsOptions = {
+    /**
+     * Display order by `chainType`. Chains not listed fall to the bottom,
+     * sorted alphabetically among themselves. Omit to use the default
+     * `ChainTypeArr` order from `@sodax/types` (stable across page reloads).
+     */
+    order?: readonly ChainType[];
 };
-declare const SodaxWalletProvider: ({ children, rpcConfig, options, initialState }: SodaxWalletProviderProps) => React.JSX.Element;
-
-declare const createWagmiConfig: (config: RpcConfig, options?: WagmiOptions) => Config<readonly [{
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Etherscan";
-            readonly url: "https://etherscan.io";
-            readonly apiUrl: "https://api.etherscan.io/api";
-        };
-    };
-    contracts: {
-        readonly ensRegistry: {
-            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-        };
-        readonly ensUniversalResolver: {
-            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
-            readonly blockCreated: 19258213;
-        };
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 14353601;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 1;
-    name: "Ethereum";
-    nativeCurrency: {
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://eth.merkle.io"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "SnowTrace";
-            readonly url: "https://snowtrace.io";
-            readonly apiUrl: "https://api.snowtrace.io";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 11907934;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 43114;
-    name: "Avalanche";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "Avalanche";
-        readonly symbol: "AVAX";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Arbiscan";
-            readonly url: "https://arbiscan.io";
-            readonly apiUrl: "https://api.arbiscan.io/api";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 7654707;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 42161;
-    name: "Arbitrum One";
-    nativeCurrency: {
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Basescan";
-            readonly url: "https://basescan.org";
-            readonly apiUrl: "https://api.basescan.org/api";
-        };
-    };
-    contracts: {
-        readonly disputeGameFactory: {
-            readonly 1: {
-                readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
-            };
-        };
-        readonly l2OutputOracle: {
-            readonly 1: {
-                readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
-            };
-        };
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 5022;
-        };
-        readonly portal: {
-            readonly 1: {
-                readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
-                readonly blockCreated: 17482143;
-            };
-        };
-        readonly l1StandardBridge: {
-            readonly 1: {
-                readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
-                readonly blockCreated: 17482143;
-            };
-        };
-        readonly gasPriceOracle: {
-            readonly address: "0x420000000000000000000000000000000000000F";
-        };
-        readonly l1Block: {
-            readonly address: "0x4200000000000000000000000000000000000015";
-        };
-        readonly l2CrossDomainMessenger: {
-            readonly address: "0x4200000000000000000000000000000000000007";
-        };
-        readonly l2Erc721Bridge: {
-            readonly address: "0x4200000000000000000000000000000000000014";
-        };
-        readonly l2StandardBridge: {
-            readonly address: "0x4200000000000000000000000000000000000010";
-        };
-        readonly l2ToL1MessagePasser: {
-            readonly address: "0x4200000000000000000000000000000000000016";
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 8453;
-    name: "Base";
-    nativeCurrency: {
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://mainnet.base.org"];
-        };
-    };
-    sourceId: 1;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters: {
-        readonly block: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcBlock) => {
-                baseFeePerGas: bigint | null;
-                blobGasUsed: bigint;
-                difficulty: bigint;
-                excessBlobGas: bigint;
-                extraData: viem.Hex;
-                gasLimit: bigint;
-                gasUsed: bigint;
-                hash: `0x${string}` | null;
-                logsBloom: `0x${string}` | null;
-                miner: `0x${string}`;
-                mixHash: viem.Hash;
-                nonce: `0x${string}` | null;
-                number: bigint | null;
-                parentBeaconBlockRoot?: `0x${string}` | undefined;
-                parentHash: viem.Hash;
-                receiptsRoot: viem.Hex;
-                sealFields: viem.Hex[];
-                sha3Uncles: viem.Hash;
-                size: bigint;
-                stateRoot: viem.Hash;
-                timestamp: bigint;
-                totalDifficulty: bigint | null;
-                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
-                transactionsRoot: viem.Hash;
-                uncles: viem.Hash[];
-                withdrawals?: viem.Withdrawal[] | undefined | undefined;
-                withdrawalsRoot?: `0x${string}` | undefined;
-            } & {};
-            type: "block";
-        };
-        readonly transaction: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcTransaction) => ({
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: boolean;
-                mint?: bigint | undefined | undefined;
-                sourceHash: viem.Hex;
-                type: "deposit";
-            } | {
-                r: viem.Hex;
-                s: viem.Hex;
-                v: bigint;
-                to: `0x${string}` | null;
-                from: `0x${string}`;
-                gas: bigint;
-                nonce: number;
-                value: bigint;
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                hash: viem.Hash;
-                input: viem.Hex;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                accessList?: undefined | undefined;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId?: number | undefined;
-                yParity?: undefined | undefined;
-                type: "legacy";
-                gasPrice: bigint;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas?: undefined | undefined;
-                maxPriorityFeePerGas?: undefined | undefined;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip2930";
-                gasPrice: bigint;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas?: undefined | undefined;
-                maxPriorityFeePerGas?: undefined | undefined;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip1559";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes: readonly viem.Hex[];
-                chainId: number;
-                type: "eip4844";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas: bigint;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList: viem.SignedAuthorizationList;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip7702";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            }) & {};
-            type: "transaction";
-        };
-        readonly transactionReceipt: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcTransactionReceipt) => {
-                blobGasPrice?: bigint | undefined;
-                blobGasUsed?: bigint | undefined;
-                blockHash: viem.Hash;
-                blockNumber: bigint;
-                contractAddress: `0x${string}` | null | undefined;
-                cumulativeGasUsed: bigint;
-                effectiveGasPrice: bigint;
-                from: `0x${string}`;
-                gasUsed: bigint;
-                logs: viem.Log<bigint, number, false>[];
-                logsBloom: viem.Hex;
-                root?: `0x${string}` | undefined;
-                status: "success" | "reverted";
-                to: `0x${string}` | null;
-                transactionHash: viem.Hash;
-                transactionIndex: number;
-                type: viem.TransactionType;
-                l1GasPrice: bigint | null;
-                l1GasUsed: bigint | null;
-                l1Fee: bigint | null;
-                l1FeeScalar: number | null;
-            } & {};
-            type: "transactionReceipt";
-        };
-    };
-    serializers: {
-        readonly transaction: typeof wagmi_chains.serializeTransactionOpStack;
-    };
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "BscScan";
-            readonly url: "https://bscscan.com";
-            readonly apiUrl: "https://api.bscscan.com/api";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 15921452;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 56;
-    name: "BNB Smart Chain";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "BNB";
-        readonly symbol: "BNB";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://56.rpc.thirdweb.com"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Sonic Explorer";
-            readonly url: "https://sonicscan.org";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 60;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 146;
-    name: "Sonic";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "Sonic";
-        readonly symbol: "S";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://rpc.soniclabs.com"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet: false;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Optimism Explorer";
-            readonly url: "https://optimistic.etherscan.io";
-            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
-        };
-    };
-    contracts: {
-        readonly disputeGameFactory: {
-            readonly 1: {
-                readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
-            };
-        };
-        readonly l2OutputOracle: {
-            readonly 1: {
-                readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
-            };
-        };
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 4286263;
-        };
-        readonly portal: {
-            readonly 1: {
-                readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
-            };
-        };
-        readonly l1StandardBridge: {
-            readonly 1: {
-                readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
-            };
-        };
-        readonly gasPriceOracle: {
-            readonly address: "0x420000000000000000000000000000000000000F";
-        };
-        readonly l1Block: {
-            readonly address: "0x4200000000000000000000000000000000000015";
-        };
-        readonly l2CrossDomainMessenger: {
-            readonly address: "0x4200000000000000000000000000000000000007";
-        };
-        readonly l2Erc721Bridge: {
-            readonly address: "0x4200000000000000000000000000000000000014";
-        };
-        readonly l2StandardBridge: {
-            readonly address: "0x4200000000000000000000000000000000000010";
-        };
-        readonly l2ToL1MessagePasser: {
-            readonly address: "0x4200000000000000000000000000000000000016";
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 10;
-    name: "OP Mainnet";
-    nativeCurrency: {
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://mainnet.optimism.io"];
-        };
-    };
-    sourceId: 1;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters: {
-        readonly block: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcBlock) => {
-                baseFeePerGas: bigint | null;
-                blobGasUsed: bigint;
-                difficulty: bigint;
-                excessBlobGas: bigint;
-                extraData: viem.Hex;
-                gasLimit: bigint;
-                gasUsed: bigint;
-                hash: `0x${string}` | null;
-                logsBloom: `0x${string}` | null;
-                miner: `0x${string}`;
-                mixHash: viem.Hash;
-                nonce: `0x${string}` | null;
-                number: bigint | null;
-                parentBeaconBlockRoot?: `0x${string}` | undefined;
-                parentHash: viem.Hash;
-                receiptsRoot: viem.Hex;
-                sealFields: viem.Hex[];
-                sha3Uncles: viem.Hash;
-                size: bigint;
-                stateRoot: viem.Hash;
-                timestamp: bigint;
-                totalDifficulty: bigint | null;
-                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
-                transactionsRoot: viem.Hash;
-                uncles: viem.Hash[];
-                withdrawals?: viem.Withdrawal[] | undefined | undefined;
-                withdrawalsRoot?: `0x${string}` | undefined;
-            } & {};
-            type: "block";
-        };
-        readonly transaction: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcTransaction) => ({
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: boolean;
-                mint?: bigint | undefined | undefined;
-                sourceHash: viem.Hex;
-                type: "deposit";
-            } | {
-                r: viem.Hex;
-                s: viem.Hex;
-                v: bigint;
-                to: `0x${string}` | null;
-                from: `0x${string}`;
-                gas: bigint;
-                nonce: number;
-                value: bigint;
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                hash: viem.Hash;
-                input: viem.Hex;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                accessList?: undefined | undefined;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId?: number | undefined;
-                yParity?: undefined | undefined;
-                type: "legacy";
-                gasPrice: bigint;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas?: undefined | undefined;
-                maxPriorityFeePerGas?: undefined | undefined;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip2930";
-                gasPrice: bigint;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas?: undefined | undefined;
-                maxPriorityFeePerGas?: undefined | undefined;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip1559";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList?: undefined | undefined;
-                blobVersionedHashes: readonly viem.Hex[];
-                chainId: number;
-                type: "eip4844";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas: bigint;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            } | {
-                blockHash: `0x${string}` | null;
-                blockNumber: bigint | null;
-                from: `0x${string}`;
-                gas: bigint;
-                hash: viem.Hash;
-                input: viem.Hex;
-                nonce: number;
-                r: viem.Hex;
-                s: viem.Hex;
-                to: `0x${string}` | null;
-                transactionIndex: number | null;
-                typeHex: viem.Hex | null;
-                v: bigint;
-                value: bigint;
-                yParity: number;
-                accessList: viem.AccessList;
-                authorizationList: viem.SignedAuthorizationList;
-                blobVersionedHashes?: undefined | undefined;
-                chainId: number;
-                type: "eip7702";
-                gasPrice?: undefined | undefined;
-                maxFeePerBlobGas?: undefined | undefined;
-                maxFeePerGas: bigint;
-                maxPriorityFeePerGas: bigint;
-                isSystemTx?: undefined | undefined;
-                mint?: undefined | undefined;
-                sourceHash?: undefined | undefined;
-            }) & {};
-            type: "transaction";
-        };
-        readonly transactionReceipt: {
-            exclude: [] | undefined;
-            format: (args: wagmi_chains.OpStackRpcTransactionReceipt) => {
-                blobGasPrice?: bigint | undefined;
-                blobGasUsed?: bigint | undefined;
-                blockHash: viem.Hash;
-                blockNumber: bigint;
-                contractAddress: `0x${string}` | null | undefined;
-                cumulativeGasUsed: bigint;
-                effectiveGasPrice: bigint;
-                from: `0x${string}`;
-                gasUsed: bigint;
-                logs: viem.Log<bigint, number, false>[];
-                logsBloom: viem.Hex;
-                root?: `0x${string}` | undefined;
-                status: "success" | "reverted";
-                to: `0x${string}` | null;
-                transactionHash: viem.Hash;
-                transactionIndex: number;
-                type: viem.TransactionType;
-                l1GasPrice: bigint | null;
-                l1GasUsed: bigint | null;
-                l1Fee: bigint | null;
-                l1FeeScalar: number | null;
-            } & {};
-            type: "transactionReceipt";
-        };
-    };
-    serializers: {
-        readonly transaction: typeof wagmi_chains.serializeTransactionOpStack;
-    };
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "PolygonScan";
-            readonly url: "https://polygonscan.com";
-            readonly apiUrl: "https://api.polygonscan.com/api";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 25770160;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 137;
-    name: "Polygon";
-    nativeCurrency: {
-        readonly name: "POL";
-        readonly symbol: "POL";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://polygon-rpc.com"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "HyperEVMScan";
-            readonly url: "https://hyperevmscan.io/";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
-            readonly blockCreated: 13051;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 999;
-    name: "HyperEVM";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "HYPE";
-        readonly symbol: "HYPE";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
-        };
-    };
-    sourceId?: number | undefined;
-    testnet?: boolean | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "LightLink Phoenix Explorer";
-            readonly url: "https://phoenix.lightlink.io";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-            readonly blockCreated: 125499184;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 1890;
-    name: "LightLink Phoenix Mainnet";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "Ether";
-        readonly symbol: "ETH";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://replicator.phoenix.lightlink.io/rpc/v1"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet: false;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-    readonly network: "lightlink-phoenix";
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "KaiaScan";
-            readonly url: "https://kaiascan.io";
-            readonly apiUrl: "https://api-cypress.klaytnscope.com/api";
-        };
-    };
-    contracts: {
-        readonly multicall3: {
-            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
-            readonly blockCreated: 96002415;
-        };
-    };
-    ensTlds?: readonly string[] | undefined;
-    id: 8217;
-    name: "Kaia";
-    nativeCurrency: {
-        readonly decimals: 18;
-        readonly name: "Kaia";
-        readonly symbol: "KAIA";
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://public-en.node.kaia.io"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet?: boolean | undefined | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}, {
-    blockExplorers: {
-        readonly default: {
-            readonly name: "Routescan";
-            readonly url: "https://redbelly.routescan.io";
-            readonly apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/151/etherscan/api";
-        };
-    };
-    contracts?: {
-        [x: string]: viem.ChainContract | {
-            [sourceId: number]: viem.ChainContract | undefined;
-        } | undefined;
-        ensRegistry?: viem.ChainContract | undefined;
-        ensUniversalResolver?: viem.ChainContract | undefined;
-        multicall3?: viem.ChainContract | undefined;
-        universalSignatureVerifier?: viem.ChainContract | undefined;
-    } | undefined;
-    ensTlds?: readonly string[] | undefined;
-    id: 151;
-    name: "Redbelly Network Mainnet";
-    nativeCurrency: {
-        readonly name: "Redbelly Native Coin";
-        readonly symbol: "RBNT";
-        readonly decimals: 18;
-    };
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly ["https://governors.mainnet.redbelly.network"];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet: false;
-    custom?: Record<string, unknown> | undefined;
-    fees?: viem.ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
-}], {
-    1: viem.HttpTransport<undefined, false>;
-    43114: viem.HttpTransport<undefined, false>;
-    42161: viem.HttpTransport<undefined, false>;
-    8453: viem.HttpTransport<undefined, false>;
-    56: viem.HttpTransport<undefined, false>;
-    146: viem.HttpTransport<undefined, false>;
-    10: viem.HttpTransport<undefined, false>;
-    137: viem.HttpTransport<undefined, false>;
-    999: viem.HttpTransport<undefined, false>;
-    1890: viem.HttpTransport<undefined, false>;
-    151: viem.HttpTransport<undefined, false>;
-    8217: viem.HttpTransport<undefined, false>;
-}, readonly wagmi.CreateConnectorFn[]>;
 /**
- * Service class for handling EVM chain interactions.
- * Implements singleton pattern and provides methods for wallet/chain operations.
+ * Aggregate view of every currently-connected chain with enriched connector
+ * metadata (name + icon) looked up from the store. Useful for "Manage
+ * connections" UIs and status badges.
+ *
+ * Gate rendering on `status === 'ready'` to avoid the "Connect wallet" →
+ * "Connected" flicker on reload while the store rehydrates from localStorage.
+ *
+ * @example
+ * const { chains, total, status } = useConnectedChains();
+ * if (status === 'loading') return <Skeleton />;
+ * return total >= 1 ? <ConnectedChainsDisplay chains={chains} /> : <ConnectCta />;
+ *
+ * @example
+ * // Deterministic display order — required if rendering a list that must
+ * // be stable across page reloads (hydrator race otherwise randomizes
+ * // insertion order).
+ * const { chains } = useConnectedChains({ order: ['EVM', 'ICON', 'SOLANA'] });
  */
-declare class EvmXService extends XService {
-    private static instance;
-    wagmiConfig: Config | undefined;
-    private constructor();
-    getXConnectors(): never[];
-    static getInstance(): EvmXService;
-    _getTokenBalance(address: string | undefined, chainId: number, tokenAddress: string): Promise<bigint>;
-    _getChainBalance(address: string | undefined, chainId: number): Promise<bigint>;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-    getBalances(address: string | undefined, xTokens: XToken[]): Promise<{}>;
-}
-
-declare class EvmXConnector extends XConnector {
-    connector: Connector;
-    constructor(connector: Connector);
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get id(): string;
-    get icon(): string | undefined;
-}
-
-declare class IconXService extends XService {
-    private static instance;
-    iconService: IconService;
-    private constructor();
-    static getInstance(): IconXService;
-    private getAggregateData;
-    getBalances(address: string | undefined, xTokens: XToken[]): Promise<{}>;
-}
-
-declare class IconHanaXConnector extends XConnector {
-    constructor();
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): string;
-}
-
-declare class InjectiveXService extends XService {
-    private static instance;
-    walletStrategy: WalletStrategy;
-    indexerGrpcAccountPortfolioApi: IndexerGrpcAccountPortfolioApi;
-    chainGrpcWasmApi: ChainGrpcWasmApi;
-    msgBroadcaster: MsgBroadcaster;
-    private constructor();
-    static getInstance(): InjectiveXService;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-}
-
-declare class InjectiveXConnector extends XConnector {
-    private wallet;
-    constructor(name: string, wallet: Wallet);
-    getXService(): InjectiveXService;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): string | undefined;
-}
-
-declare class SolanaXService extends XService {
-    private static instance;
-    connection: Connection | undefined;
-    wallet: WalletContextState | undefined;
-    private constructor();
-    static getInstance(): SolanaXService;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-}
-
-declare class SolanaXConnector extends XConnector {
-    wallet: any;
-    constructor(wallet: any);
-    getXService(): SolanaXService;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): any;
-}
-
-declare class CustomSorobanServer extends SorobanRpc.Server {
-    private readonly customHeaders;
-    constructor(serverUrl: string, customHeaders: Record<string, string>);
-    simulateTransaction(tx: Transaction<Memo<MemoType>, Operation[]>): Promise<SorobanRpc.Api.SimulateTransactionResponse>;
-    sendTransaction(tx: Transaction | FeeBumpTransaction): Promise<SorobanRpc.Api.SendTransactionResponse>;
-    getTransaction(hash: string): Promise<SorobanRpc.Api.GetTransactionResponse>;
-}
+declare function useConnectedChains({ order }?: UseConnectedChainsOptions): UseConnectedChainsResult;
 
-declare class StellarXService extends XService {
-    private static instance;
-    walletsKit: StellarWalletsKit;
-    server: StellarSdk.Horizon.Server;
-    sorobanServer: CustomSorobanServer;
-    private constructor();
-    static getInstance(): StellarXService;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-}
-
-type StellarWalletType = {
-    icon: string;
-    id: string;
-    isAvailable: boolean;
-    name: string;
-    type: string;
-    url: string;
+type UseXDisconnectArgs = {
+    xChainType: ChainType;
 };
-declare class StellarWalletsKitXConnector extends XConnector {
-    _wallet: StellarWalletType;
-    constructor(wallet: StellarWalletType);
-    getXService(): StellarXService;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): string;
-}
-
-declare class SuiXService extends XService {
-    private static instance;
-    suiClient: any;
-    suiWallet: any;
-    suiAccount: any;
-    private constructor();
-    static getInstance(): SuiXService;
-    getBalances(address: string | undefined, xTokens: readonly XToken[]): Promise<Record<string, bigint>>;
-}
-
-declare class SuiXConnector extends XConnector {
-    wallet: any;
-    constructor(wallet: any);
-    getXService(): SuiXService;
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): any;
-}
-
-declare class StacksXService extends XService {
-    private static instance;
-    network: StacksNetwork | undefined;
-    private constructor();
-    static getInstance(): StacksXService;
-    getBalance(address: string | undefined, xToken: XToken): Promise<bigint>;
-}
-
-interface StacksProviderConfig {
-    /** The provider ID matching the window path, e.g. 'LeatherProvider' or 'XverseProviders.BitcoinProvider' */
-    id: string;
-    name: string;
-    icon: string;
-    installUrl?: string;
-}
-declare class StacksXConnector extends XConnector {
-    private readonly config;
-    constructor(config: StacksProviderConfig);
-    connect(): Promise<XAccount | undefined>;
-    disconnect(): Promise<void>;
-    get icon(): string;
-    getProvider(): StacksProvider | undefined;
-}
-
-declare const STACKS_PROVIDERS: StacksProviderConfig[];
-
-declare function useStacksXConnectors(): StacksXConnector[];
-
-declare function useXAccount(chainIdentifier?: ChainType | ChainId): XAccount;
-
-declare function useXAccounts(): Partial<Record<"ICON" | "EVM" | "INJECTIVE" | "SUI" | "STELLAR" | "SOLANA" | "STACKS" | "NEAR" | "BITCOIN", XAccount>>;
-
 /**
- * Hook for connecting to various blockchain wallets across different chains
+ * Returns a callback that disconnects the wallet for a given chain type.
+ *
+ * The callback delegates to the chain's `ChainActions.disconnect()` — provider-managed
+ * chains (EVM/Solana/Sui) trigger native SDK disconnect and let the Hydrator clear the
+ * store; non-provider chains call `unsetXConnection` directly.
+ *
+ * **Never throws.** When no `ChainActions` are registered (chain not enabled in
+ * `SodaxWalletProvider` config), the callback logs a warning and resolves silently.
+ * Even if the wallet's native disconnect throws, the store is cleared — the UI never
+ * gets stuck on "connected" state.
  *
- * Handles connection logic for EVM, SUI, Solana and other supported chains.
- * Sets up wallet connections and stores connection state in XWagmiStore.
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONNECT_FLOW.md#disconnect | Connect Flow — Disconnect}
+ */
+declare function useXDisconnect(): (args: UseXDisconnectArgs) => Promise<void>;
+
+type ConnectionStatus = 'idle' | 'connecting' | 'success' | 'error';
+type UseConnectionFlowResult = {
+    /** `'idle' | 'connecting' | 'success' | 'error'` — reflects the last attempt. */
+    status: ConnectionStatus;
+    /** Raw error from the last failed attempt; null when no error. Inspect `activeConnector.isInstalled` for the install-CTA branch. */
+    error: Error | null;
+    /** Connector the current / last attempt targeted. */
+    activeConnector: XConnector | null;
+    /** Chain the current / last attempt targeted. */
+    activeChainType: ChainType | null;
+    /** Connect and return the resolved account. Errors populate `error` instead of throwing. */
+    connect: (connector: XConnector) => Promise<XAccount | undefined>;
+    /** Disconnect a specific chain. Matches `useXDisconnect` semantics. */
+    disconnect: (args: UseXDisconnectArgs) => Promise<void>;
+    /** Re-runs the last attempted `connect(connector)`. No-op if no prior attempt. */
+    retry: () => Promise<XAccount | undefined>;
+    /** Clears `status`, `error`, and `activeConnector`. */
+    reset: () => void;
+};
+/**
+ * Wrapper around `useXConnect` + `useXDisconnect` that surfaces the raw error
+ * on state instead of throwing, plus tracks the active connector and exposes
+ * `retry()`. Unlike calling `useXConnect` directly, `connect()` here never
+ * throws — errors flow into `error` so render code stays linear.
  *
- * @param {void} - No parameters required
- * @returns {UseMutationResult<XAccount | undefined, Error, XConnector>} Mutation result containing:
- * - mutateAsync: Function to connect a wallet
- * - isPending: Boolean indicating if connection is in progress
- * - error: Any error that occurred
- * - data: Connected account data if successful
+ * For the "install CTA" branch, read `activeConnector.isInstalled` and
+ * `activeConnector.installUrl` (populated by Phase 1). No error classification
+ * is done here — consumers log the raw error for unrecognized cases.
  *
  * @example
- * ```ts
- * const { mutateAsync: connect, isPending } = useXConnect();
- *
- * const handleConnect = async (connector: XConnector) => {
- *   try {
- *     await connect(connector);
- *   } catch (err) {
- *     console.error(err);
+ * const { status, error, connect, retry, activeConnector } = useConnectionFlow();
+ *
+ * if (status === 'error' && error) {
+ *   if (activeConnector && !activeConnector.isInstalled) {
+ *     return <a href={activeConnector.installUrl}>Install →</a>;
  *   }
- * };
- * ```
+ *   return <button onClick={retry}>Failed — retry</button>;
+ * }
+ *
+ * return (
+ *   <button onClick={() => connect(connector)} disabled={status === 'connecting'}>
+ *     {status === 'connecting' ? 'Waiting for wallet…' : 'Connect'}
+ *   </button>
+ * );
  */
-declare function useXConnect(): UseMutationResult<XAccount | undefined, Error, XConnector>;
+declare function useConnectionFlow(): UseConnectionFlowResult;
+
+/** Lifecycle of a sequential batch operation (`useBatchConnect`, `useBatchDisconnect`). */
+type BatchOperationStatus = 'idle' | 'running' | 'done';
 
 /**
- * Hook for accessing connection details for a specific blockchain
- *
- * Retrieves the current connection state for the specified chain type,
- * including the connected account and connector ID.
+ * Per-target event emitted by `onProgress` as the batch advances. Lets consumers
+ * render a live "EVM: connecting… done; ICON: skipped; SUI: connecting…" log
+ * instead of waiting for the final `run()` promise.
+ */
+type BatchConnectProgressEvent = {
+    chainType: ChainType;
+    outcome: 'success';
+} | {
+    chainType: ChainType;
+    outcome: 'failure';
+    error: Error;
+} | {
+    chainType: ChainType;
+    outcome: 'skipped';
+};
+type BatchConnectResult = {
+    /** Chain types where the connect attempt succeeded. */
+    successful: ChainType[];
+    /** Chain types where the connect attempt threw, paired with the raw error. */
+    failed: Array<{
+        chainType: ChainType;
+        error: Error;
+    }>;
+    /** Chain types skipped because `{ skipConnected: true }` and an account was already present. */
+    skipped: ChainType[];
+};
+type UseBatchConnectOptions = {
+    /**
+     * Wallet brand identifiers (e.g. `'hana'`, `'phantom'`). Matched via
+     * case-insensitive substring against `connector.id` and `connector.name` —
+     * see {@link matchesConnectorIdentifier}.
+     *
+     * Resolution is **per-chain priority with fallback-on-failure**: for each
+     * chain, every matching connector is queued in identifier order. The runner
+     * tries them sequentially and stops at the first one that connects. If an
+     * earlier identifier's connector fails (popup denied, extension error, …),
+     * the next identifier's connector is tried. Subsequent identifiers are
+     * silently skipped once a chain succeeds — only one popup per chain on the
+     * happy path.
+     *
+     * To target a specific connector (not a brand), use
+     * `useXConnectors(chainType).find(c => c.id === '...')` directly instead of
+     * this API.
+     *
+     * @example ['hana']             // Hana across every chain it supports
+     * @example ['hana', 'phantom']  // prefer Hana per chain; if Hana fails or
+     *                                // is unavailable on a chain, fall back to
+     *                                // Phantom (e.g. Solana).
+     */
+    connectors: readonly string[];
+    /** Skip chains whose account is already connected at `run()` time. */
+    skipConnected?: boolean;
+    /**
+     * Fires once per target as the batch progresses. Useful for live progress UI
+     * (a spinner-per-chain list). Errors thrown from `onProgress` are caught and
+     * logged — they do NOT fail the batch.
+     */
+    onProgress?: (event: BatchConnectProgressEvent) => void;
+};
+type UseBatchConnectResult = {
+    run: () => Promise<BatchConnectResult>;
+    status: BatchOperationStatus;
+    result: BatchConnectResult | null;
+    /**
+     * Clears `status` and `result`. Calling `reset()` while `status === 'running'`
+     * only clears the observable state — the in-flight batch is NOT aborted
+     * (there is no cancellation signal). When the batch eventually resolves,
+     * `status` flips to `'done'` and `result` populates again. Typical usage
+     * is to call `reset()` only after `status === 'done'`.
+     */
+    reset: () => void;
+};
+/**
+ * Connect every chain where one of the supplied wallet identifiers matches
+ * an available connector. Sequential (safe for extensions that share popup
+ * singletons); errors never throw from `run()` — failures are collected into
+ * `result.failed`.
  *
- * @param {ChainType} xChainType - The type of blockchain to get connection details for
- * @returns {XConnection | undefined} Connection details including account and connector ID, or undefined if not connected
+ * Replaces the apps/web-era per-wallet wrappers
+ * (`useConnectAllWithHana`, `useConnectRestWithHana`): pass the wallet name(s)
+ * and the hook discovers all compatible chains from the registry.
  *
  * @example
- * ```ts
- * const connection = useXConnection('EVM');
+ * // Connect Hana on every chain it supports (EVM, ICON, Solana, Sui, Stellar...)
+ * const { run, status, result } = useBatchConnect({ connectors: ['hana'] });
+ * await run();
  *
- * if (connection) {
- *   console.log('Connected account:', connection.xAccount.address);
- *   console.log('Using connector:', connection.xConnectorId);
- * }
- * ```
+ * @example
+ * // Only connect chains not already connected
+ * const { run } = useBatchConnect({ connectors: ['hana'], skipConnected: true });
+ * await run();
  */
-declare function useXConnection(xChainType: ChainType | undefined): XConnection | undefined;
+declare function useBatchConnect({ connectors, skipConnected, onProgress, }: UseBatchConnectOptions): UseBatchConnectResult;
 
 /**
- * Hook to retrieve available wallet connectors for a specific blockchain type.
+ * Per-target event emitted by `onProgress` as the batch advances.
+ */
+type BatchDisconnectProgressEvent = {
+    chainType: ChainType;
+    outcome: 'success';
+} | {
+    chainType: ChainType;
+    outcome: 'failure';
+    error: Error;
+};
+type BatchDisconnectResult = {
+    /** Chain types where disconnect succeeded. */
+    successful: ChainType[];
+    /** Chain types where disconnect threw, paired with the raw error. */
+    failed: Array<{
+        chainType: ChainType;
+        error: Error;
+    }>;
+};
+type UseBatchDisconnectOptions = {
+    /**
+     * Wallet brand identifiers to scope the disconnect (e.g. `'hana'`,
+     * `'xverse'`). Matched via case-insensitive substring against
+     * `connector.id` and `connector.name` — see {@link matchesConnectorIdentifier}.
+     * Only chains whose *currently active* connector matches at least one
+     * identifier are disconnected.
+     *
+     * Omit this field to disconnect every currently-connected chain regardless
+     * of which wallet is active.
+     *
+     * To target a specific connector (not a brand), use
+     * `useXConnectors(chainType).find(c => c.id === '...')` + `useXDisconnect`
+     * directly instead of this API.
+     *
+     * @example ['hana']            // disconnect every chain Hana is connected on
+     * @example ['hana', 'xverse']  // disconnect chains with Hana OR Xverse active
+     */
+    connectors?: readonly string[];
+    /**
+     * Fires once per target as the batch progresses. Errors thrown from
+     * `onProgress` are caught and logged — they do NOT fail the batch.
+     */
+    onProgress?: (event: BatchDisconnectProgressEvent) => void;
+};
+type UseBatchDisconnectResult = {
+    run: () => Promise<BatchDisconnectResult>;
+    status: BatchOperationStatus;
+    result: BatchDisconnectResult | null;
+    /**
+     * Clears `status` and `result`. Calling `reset()` while `status === 'running'`
+     * only clears the observable state — the in-flight batch is NOT aborted
+     * (there is no cancellation signal). When the batch eventually resolves,
+     * `status` flips to `'done'` and `result` populates again. Typical usage
+     * is to call `reset()` only after `status === 'done'`.
+     */
+    reset: () => void;
+};
+/**
+ * Disconnect chains sequentially, optionally scoped to a specific wallet.
+ * Mirrors {@link useBatchConnect}'s identifier-based API:
+ *
+ * @example
+ * // Disconnect every chain Hana is currently connected on
+ * const { run } = useBatchDisconnect({ connectors: ['hana'] });
+ * await run();
  *
- * This hook aggregates wallet connectors from different blockchain ecosystems:
- * - EVM: Uses wagmi connectors
- * - Sui: Uses Sui wallet adapters
- * - Stellar: Uses custom Stellar connectors
- * - Solana: Uses Solana wallet adapters (filtered to installed wallets only)
+ * @example
+ * // Disconnect every currently-connected chain regardless of wallet
+ * const { run } = useBatchDisconnect();
+ * await run();
  *
- * @param xChainType - The blockchain type to get connectors for ('EVM' | 'SUI' | 'STELLAR' | 'SOLANA' | 'NEAR' | 'STACKS')
- * @returns An array of XConnector instances compatible with the specified chain type
+ * Best-effort: errors are collected, not thrown. `run()` is idempotent — a
+ * double-invocation while one batch is in flight returns the same promise.
  */
-declare function useXConnectors(xChainType: ChainType | undefined): XConnector[];
+declare function useBatchDisconnect({ connectors, onProgress, }?: UseBatchDisconnectOptions): UseBatchDisconnectResult;
 
 /**
- * Hook for disconnecting from a specific blockchain wallet
- *
- * Handles disconnection logic for EVM, SUI, Solana and other supported chains.
- * Clears connection state from XWagmiStore.
+ * Discriminated union for the wallet-modal flow state machine.
+ * See `useWalletModal()` for transitions and consumer usage.
+ */
+type WalletModalState = {
+    kind: 'closed';
+} | {
+    kind: 'chainSelect';
+} | {
+    kind: 'walletSelect';
+    chainType: ChainType;
+} | {
+    kind: 'connecting';
+    chainType: ChainType;
+    connector: XConnector;
+} | {
+    kind: 'success';
+    chainType: ChainType;
+    connector: XConnector;
+    account: XAccount;
+} | {
+    kind: 'error';
+    chainType: ChainType;
+    connector: XConnector;
+    error: Error;
+};
+
+type UseWalletModalOptions = {
+    /**
+     * Fires once after a successful connect attempt initiated through the modal,
+     * before the consumer transitions away from the `success` state. Side-effects
+     * the SDK shouldn't bake in (registration check, terms-of-service modal, app
+     * routing) belong here.
+     */
+    onConnected?: (chainType: ChainType, account: XAccount) => void | Promise<void>;
+    /**
+     * How long (ms) to wait for a provider-managed chain's Hydrator to populate
+     * `xConnections[chainType]` with an account whose `xConnectorId` matches the
+     * connector the user picked. Defaults to 5000ms. Raise this for slow
+     * networks / wallets that take a long time to surface the account after
+     * the user approves the popup. Ignored for non-provider chains (Bitcoin,
+     * ICON, Stellar, NEAR, Stacks, Injective) — those return the account
+     * directly from `connect()`.
+     */
+    hydrationTimeoutMs?: number;
+};
+/**
+ * WalletConnect UX caveat
+ * -----------------------
+ * When the user picks an EVM WalletConnect connector, wagmi opens its own QR
+ * modal as a third-party UI. While that QR modal is visible, `useWalletModal`
+ * stays in `connecting` — the consumer may prefer to auto-hide the Sodax
+ * modal to avoid two dialogs stacking. Detect WC via
+ * `state.kind === 'connecting' && state.connector.id === 'walletConnect'`
+ * (wagmi's connector id) and conditionally render `null` until the attempt
+ * resolves. Not wired into the SDK because partners integrating their own
+ * dialog system decide the policy (hide, fade, keep).
+ */
+type UseWalletModalResult = {
+    /** Discriminated union — switch on `state.kind` for type-narrowed fields. */
+    state: WalletModalState;
+    /** Transition `closed → chainSelect`. No-op if already open. */
+    open: () => void;
+    /** Transition any → `closed`. */
+    close: () => void;
+    /**
+     * Smart back: walletSelect → chainSelect; connecting/error → walletSelect
+     * (preserve chainType so user can pick another wallet or retry); success → closed;
+     * closed/chainSelect → no-op.
+     */
+    back: () => void;
+    /** Transition `chainSelect → walletSelect(chainType)`. */
+    selectChain: (chainType: ChainType) => void;
+    /**
+     * Transition `walletSelect → connecting → success | error`. Composes
+     * `useXConnect` internally; failures populate `state.error` instead of
+     * throwing.
+     *
+     * Concurrency:
+     * - Same connector already in flight → returns the same promise (dedupes
+     *   double-clicks).
+     * - Different connector clicked before the previous attempt settles → starts
+     *   a new attempt; the previous attempt's late resolution is dropped and
+     *   does not overwrite the current state.
+     * - User calls `back()` / `close()` mid-connect → the in-flight attempt's
+     *   late resolution is dropped and does not transition to `success`/`error`.
+     *
+     * `back()` / `close()` mid-connect caveat: if the wallet already approved
+     * before the transition, `xConnections` is populated by `useXConnect` /
+     * the Hydrator independently of the modal state machine. Leaving the
+     * `connecting` state only drops the pending `success`/`error` transition
+     * — the account stays connected. Call `useXDisconnect(chainType)` from
+     * the same handler that calls `back()` / `close()` if a full rollback is
+     * required.
+     */
+    selectWallet: (connector: XConnector) => Promise<XAccount | undefined>;
+    /** Re-runs the last `selectWallet` from an `error` state. No-op otherwise. */
+    retry: () => Promise<XAccount | undefined>;
+};
+/**
+ * Headless modal lifecycle for multi-chain wallet connection. Owns the flow
+ * `closed → chainSelect → walletSelect → connecting → success | error` as a
+ * Zustand slice so multiple components (header CTA, inline buttons, settings)
+ * see the same lifecycle without prop drilling.
  *
- * @param {void} - No parameters required
- * @returns {(xChainType: ChainType) => Promise<void>} Async function that disconnects from the specified chain
+ * The hook is render-agnostic — pair it with any dialog/drawer/inline UI:
  *
  * @example
- * ```ts
- * const disconnect = useXDisconnect();
+ * const modal = useWalletModal({
+ *   onConnected: async (chainType, account) => {
+ *     // App-specific side effect (e.g. terms-of-service check)
+ *     await registerIfNew(chainType, account.address);
+ *   },
+ * });
  *
- * const handleDisconnect = async (xChainType: ChainType) => {
- *   await disconnect(xChainType);
- * };
- * ```
+ * switch (modal.state.kind) {
+ *   case 'closed':       return <button onClick={modal.open}>Connect</button>;
+ *   case 'chainSelect':  return <ChainList onPick={modal.selectChain} onBack={modal.close} />;
+ *   case 'walletSelect': return <WalletList chainType={modal.state.chainType} onPick={modal.selectWallet} onBack={modal.back} />;
+ *   case 'connecting':   return <Spinner connector={modal.state.connector} />;
+ *   case 'success':      return null; // onConnected fired; consumer can call modal.close()
+ *   case 'error':        return <ErrorView error={modal.state.error} onRetry={modal.retry} onBack={modal.back} />;
+ * }
  */
-declare function useXDisconnect(): (xChainType: ChainType) => Promise<void>;
-
-declare function useXService(xChainType: ChainType | undefined): XService | undefined;
+declare function useWalletModal({ onConnected, hydrationTimeoutMs, }?: UseWalletModalOptions): UseWalletModalResult;
 
+type UseXServiceOptions = {
+    xChainType?: ChainType;
+};
 /**
- * Hook to fetch token balances for multiple tokens on a specific chain
+ * Returns the chain-specific `XService` instance for advanced reads — balance lookups
+ * (`xService.getBalance(address, xToken)`), connector enumeration, or chain-specific
+ * methods on concrete subclasses.
  *
- * @param params - Query parameters object
- * @param params.xChainId - Chain identifier (e.g. '0xa86a.avax', '0x1.base', '0x2.bsc', '0x89.polygon', '0x1.optimism')
- * @param params.xTokens - Array of token objects to fetch balances for.
- * @param params.address - Wallet address to fetch balances for. If undefined, returns empty object
+ * Most consumers don't need this — `useWalletProvider` is the higher-level bridge to
+ * `@sodax/sdk`, and `useXConnectors` returns the connector list directly. Reach for
+ * `useXService` only when you need the service object itself (e.g. passing it to
+ * `useXBalances` from `@sodax/dapp-kit`).
  *
- * @returns UseQueryResult containing an object mapping token addresses to their balances as bigints.
- *          The balances are denominated in the token's smallest unit (e.g. wei for ETH).
- *          Returns empty object if wallet is not connected or service is unavailable.
+ * Returns `undefined` when `xChainType` is omitted or the chain isn't enabled.
  */
+declare function useXService({ xChainType }?: UseXServiceOptions): XService | undefined;
+
 /**
- * @example
- * ```tsx
- * // Example usage in a component
- * function TokenBalances({ tokens }: { tokens: XToken[] }) {
- *   const { address } = useXAccount('EVM');
- *   const { data: balances } = useXBalances({
- *     xChainId: '0xa86a.avax',
- *     xTokens: tokens,
- *     address,
- *   });
- *
- *   return (
- *     <div>
- *       {tokens.map(token => (
- *         <div key={token.address}>
- *           {token.symbol}: {formatUnits(balances?.[token.address] || 0n, token.decimals)}
- *         </div>
- *       ))}
- *     </div>
- *   );
- * }
- * ```
+ * Returns the `XService` instance for every enabled chain, keyed by `ChainType`.
+ *
+ * Each service singleton owns its connector list and exposes balance readers; concrete
+ * subclasses (e.g. `EvmXService`, `BitcoinXService`) carry chain-specific methods. For
+ * a single chain, prefer `useXService` which is keyed by `xChainType` directly.
+ */
+declare function useXServices(): Partial<Record<ChainType, XService>>;
+
+/**
+ * Reads the list of `ChainType`s currently enabled in `SodaxWalletProvider` config.
+ *
+ * Reflects which chain-type slots are present (`config.EVM`, `config.SOLANA`, …) — not
+ * which chains have a wallet connected. Use `useConnectedChains` for the latter.
+ *
+ * @returns Stable array reference; re-renders only when `enabledChains` changes (i.e. on
+ * `initChainServices` after mount, never afterwards because config is captured once).
  */
-declare function useXBalances({ xChainId, xTokens, address, }: {
-    xChainId: ChainId;
-    xTokens: readonly XToken[];
-    address: string | undefined;
-}): UseQueryResult<{
-    [key: string]: bigint;
-}>;
+declare function useEnabledChains(): ChainType[];
 
-interface UseEvmSwitchChainReturn {
+type UseEvmSwitchChainOptions = {
+    xChainId: SpokeChainKey;
+};
+type UseEvmSwitchChainReturn = {
     isWrongChain: boolean;
     handleSwitchChain: () => void;
-}
-declare const useEvmSwitchChain: (expectedXChainId: ChainId) => UseEvmSwitchChainReturn;
+};
+/**
+ * Hook to handle EVM chain switching functionality.
+ * Safe to call when EVM is disabled — returns no-op values.
+ *
+ * Conditionally delegates to useEvmSwitchChainInner which uses wagmi hooks
+ * (useAccount, useSwitchChain) that require WagmiProvider. When EVM is disabled,
+ * WagmiProvider is not mounted, so we must not call those hooks.
+ *
+ * This technically violates Rules of Hooks (conditional hook call), but is safe
+ * because `evmEnabled` is derived from config which is immutable after mount —
+ * the branch never changes during the component's lifetime.
+ */
+declare function useEvmSwitchChain({ xChainId }: UseEvmSwitchChainOptions): UseEvmSwitchChainReturn;
+
+/** Empty slot in `walletProviders` is normal before a wallet is connected. */
+type GetWalletProviderReturnType<K extends ChainType | undefined> = K extends ChainType ? GetWalletProviderType<K> | undefined : undefined;
 
+type UseWalletProviderOptions = {
+    xChainId?: SpokeChainKey;
+    xChainType?: ChainType;
+};
 /**
- * Hook to get the appropriate wallet provider based on the chain type.
- * Supports EVM, SUI, ICON, INJECTIVE, STELLAR, SOLANA and NEAR chains.
+ * Returns the typed `IXxxWalletProvider` instance for the requested chain — ready to plug
+ * into any `@sodax/sdk` call's `walletProvider` slot.
  *
- * @param {ChainId | undefined} spokeChainId - The chain ID to get the wallet provider for. Can be any valid ChainId value.
- * @returns {EvmWalletProvider | SuiWalletProvider | IconWalletProvider | InjectiveWalletProvider | undefined}
- * The appropriate wallet provider instance for the given chain ID, or undefined if:
- * - No chain ID is provided
- * - Chain type is not supported
- * - Required wallet provider options are not available
+ * Pass either `xChainId` (a `SpokeChainKey`) or `xChainType` (a `ChainType` family),
+ * never both. The chain key form gives the narrowest TypeScript inference (e.g.
+ * `xChainId: ChainKeys.BSC_MAINNET` → `IEvmWalletProvider | undefined`).
  *
- * @example
- * ```tsx
- * // Get wallet provider for a specific chain
- * const walletProvider = useWalletProvider('sui');
- * ```
+ * Returns `undefined` when:
+ * - The chain isn't enabled in `SodaxWalletProvider` config (logs a one-time warning).
+ * - No wallet is connected for that chain yet.
+ *
+ * For provider-managed chains (EVM/Solana/Sui), the returned provider is rebuilt by the
+ * Hydrator whenever the underlying client changes (chain switch, wallet swap). For
+ * non-provider chains, the provider is created as a side-effect of `setXConnection`.
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/WALLET_PROVIDER_BRIDGE.md | Wallet Provider Bridge}
  */
-declare function useWalletProvider(spokeChainId: ChainId | undefined): IEvmWalletProvider | ISuiWalletProvider | IIconWalletProvider | IInjectiveWalletProvider | IStellarWalletProvider | ISolanaWalletProvider | IBitcoinWalletProvider | INearWalletProvider | IStacksWalletProvider | undefined;
+declare function useWalletProvider<S extends SpokeChainKey>(options: {
+    xChainId: S;
+    xChainType?: never;
+}): GetWalletProviderType<GetChainType<S>> | undefined;
+declare function useWalletProvider<K extends ChainType | undefined>(options?: {
+    xChainId?: never;
+    xChainType?: K;
+}): GetWalletProviderReturnType<K> | undefined;
 
 type SignMessageReturnType = `0x${string}` | Uint8Array | string | undefined;
-declare function useXSignMessage(): UseMutationResult<SignMessageReturnType, Error, {
+type XSignMessageVariables = {
     xChainType: ChainType;
     message: string;
-}, unknown>;
+};
+/**
+ * React Query mutation that delegates message signing to the connected wallet via
+ * `ChainActions.signMessage` — registered per chain by the `chainRegistry` (non-provider
+ * chains) or by the `<Chain>Actions` component (provider-managed chains).
+ *
+ * The signature shape varies by chain: hex `\`0x${string}\`` for EVM, `Uint8Array` for
+ * Solana, base64 `string` for Stellar/Sui, etc. Branch on `xChainType` when consuming.
+ *
+ * **Bitcoin auto-selects** between BIP-322 (P2WPKH/P2TR) and ECDSA (P2SH/P2PKH) based
+ * on the connected address type — same dispatch logic as the SDK's
+ * `BitcoinSpokeProvider.authenticateWithWallet`.
+ *
+ * **Returns `undefined`** when the chain doesn't implement `signMessage` — currently
+ * only ICON (Hana wallet exposes no signing API). A one-time `console.warn` accompanies
+ * the `undefined`.
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/SIGN_MESSAGE.md | Sign Message}
+ */
+declare function useXSignMessage(): UseMutationResult<SignMessageReturnType, Error, XSignMessageVariables, unknown>;
 
-type XWagmiStore = {
-    xServices: Partial<Record<ChainType, XService>>;
-    xConnections: Partial<Record<ChainType, XConnection>>;
-    setXConnection: (xChainType: ChainType, xConnection: XConnection) => void;
-    unsetXConnection: (xChainType: ChainType) => void;
+type SodaxWalletProviderProps = {
+    children: ReactNode;
+    /**
+     * Captured once on mount. Dynamic changes require remounting `SodaxWalletProvider`
+     * — passing a new reference on subsequent renders has no effect.
+     */
+    config: SodaxWalletConfig;
 };
-declare const useXWagmiStore: zustand.UseBoundStore<Omit<Omit<Omit<zustand.StoreApi<XWagmiStore>, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(partial: XWagmiStore | Partial<XWagmiStore> | ((state: XWagmiStore) => XWagmiStore | Partial<XWagmiStore>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<XWagmiStore, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: XWagmiStore) => void) => () => void;
-        onFinishHydration: (fn: (state: XWagmiStore) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<XWagmiStore, unknown>>;
-    };
-}, "setState"> & {
-    setState(nextStateOrUpdater: XWagmiStore | Partial<XWagmiStore> | ((state: immer.WritableDraft<XWagmiStore>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: string;
-    } | undefined): void;
-}>;
+/**
+ * Root provider for SODAX wallet connectivity. Mounts only the chain-type adapters opted
+ * into via `config` and bridges to `@sodax/wallet-sdk-core` so SDK calls receive a typed
+ * `IXxxWalletProvider`.
+ *
+ * Top-level keys on `SodaxWalletConfig` are chain-type slots (`EVM`, `SOLANA`, `BITCOIN`, …).
+ * Omit a slot to skip mounting that adapter; pass `{}` to mount with SDK defaults. Provider-
+ * managed chains (EVM/Solana/Sui) wrap their native React adapter (wagmi / wallet-adapter /
+ * dapp-kit) plus a `<Hydrator>` that syncs adapter state into the Zustand store; non-provider
+ * chains register `ChainActions` directly during `useInitChainServices`.
+ *
+ * **Config is captured once on mount** via `useRef` — subsequent re-renders with a new
+ * reference have no effect. To swap config at runtime, remount with a new `key` prop.
+ *
+ * Must be wrapped by `<QueryClientProvider>` from `@tanstack/react-query` (or, if also
+ * using `@sodax/dapp-kit`, see Setup skill for the full provider-stack ordering).
+ *
+ * @see {@link https://github.com/icon-project/sodax-sdks/blob/main/packages/wallet-sdk-react/docs/CONFIGURE_PROVIDER.md | Configure SodaxWalletProvider}
+ */
+declare const SodaxWalletProvider: ({ children, config }: SodaxWalletProviderProps) => react_jsx_runtime.JSX.Element;
 
-export { BitcoinXConnector, BitcoinXService, type CurrencyKey, EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InjectiveXConnector, InjectiveXService, OKXXConnector, STACKS_PROVIDERS, SodaxWalletProvider, type SodaxWalletProviderOptions, type SodaxWalletProviderProps, SolanaXConnector, SolanaXService, type StacksProviderConfig, StacksXConnector, StacksXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, UnisatXConnector, type WagmiOptions, WalletId, type XAccount, type XConnection, XConnector, XService, XverseXConnector, createWagmiConfig as createWagmi, createWagmiConfig, getWagmiChainId, getXChainType, getXService, isNativeToken, useBitcoinXConnectors, useEvmSwitchChain, useStacksXConnectors, useWalletProvider, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXSignMessage, useXWagmiStore };
+export { type BatchConnectProgressEvent, type BatchConnectResult, type BatchDisconnectProgressEvent, type BatchDisconnectResult, type BatchOperationStatus, type ChainActions, type ChainActionsRegistry, ChainEntry, type ChainGroup, type ConnectedChain, type ConnectionStatus, EvmChainEntry, IXConnector, SodaxWalletConfig, SodaxWalletProvider, type SodaxWalletProviderProps, type SortConnectorsOptions, type UseBatchConnectOptions, type UseBatchConnectResult, type UseBatchDisconnectOptions, type UseBatchDisconnectResult, type UseChainGroupsOptions, type UseConnectedChainsOptions, type UseConnectedChainsResult, type UseConnectionFlowResult, type UseEvmSwitchChainOptions, type UseEvmSwitchChainReturn, type UseIsWalletInstalledOptions, type UseWalletModalOptions, type UseWalletModalResult, type UseWalletProviderOptions, type UseXAccountOptions, type UseXConnectionOptions, type UseXConnectorsOptions, type UseXDisconnectArgs, type UseXServiceOptions, WalletConfigProvider, WalletDefaultsByKey, type WalletModalState, XAccount, XConnection, XConnector, XService, type XSignMessageVariables, getEntryDefaults, getRpcUrl, getWagmiChainId, getXChainType, getXService, isNativeToken, resolveEvmDefaults, sortConnectors, useBatchConnect, useBatchDisconnect, useChainGroups, useConnectedChains, useConnectionFlow, useEnabledChainTypes, useEnabledChains, useEvmSwitchChain, useIsChainEnabled, useIsWalletInstalled, useWalletConfig, useWalletModal, useWalletProvider, useXAccount, useXAccounts, useXConnect, useXConnection, useXConnections, useXConnectors, useXConnectorsByChain, useXDisconnect, useXService, useXServices, useXSignMessage };