@naculus/connect-appkit-react 0.1.9 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2270 @@
+import * as _naculus_connect_core from '@naculus/connect-core';
+import { UniversalWalletSession, WalletCapabilities, DelegationStatus, ExecutionPlan, AtomicityRequirement, BatchCall, SessionKeyInfo, ScopeCheckResult, SessionKeyTransaction, Hex, SessionKeyManagerConfig, SessionKeyScope, TokenConfig, NameResolverConfig, NameResult, InAppChannel, NotificationItem, NotificationSettings, PassphraseRequest, PassphraseGate, AddressResult, ExecutionStrategy, CallsStatus, Address as Address$1, Call, SendUserOpOptions, UserOperationResponse, UserOperationReceipt, ActiveSessionBundle, ChainSession, SmartAccountInfo, SolanaBalance, SolanaConfirmationStatus, SessionManager, TokenListSource, TokenListEntry, TokenSearchResult } from '@naculus/connect-core';
+export { LAMPORTS_PER_SOL, PassphraseCancelledError, PassphraseGate, PassphraseIntent, PassphraseRequest, SolanaBalance, SolanaConfirmationStatus, SolanaRpcError, formatSol, getLatestBlockhash, getSignatureStatus, getSolanaBalance, parseSol } from '@naculus/connect-core';
+import { PocketConfig, WalletAccount, WalletNamespace, WalletData, StorageSecurityReport } from '@naculus/connector-embedded';
+export { StorageSecurityFinding, StorageSecurityReport, WalletAccount, WalletData, WalletNamespace } from '@naculus/connector-embedded';
+import { Web3Client } from './client.js';
+export { ClientConfig, clearClient, createClient, getClient } from './client.js';
+import * as _naculus_connect_appkit_core from '@naculus/connect-appkit-core';
+import { Web3State, WalletChain, ChainInfo } from '@naculus/connect-appkit-core';
+export { ChainInfo, ConnectionStatus, WalletChain, Web3State } from '@naculus/connect-appkit-core';
+import { Address, PublicClient, WalletClient } from 'viem';
+import { SimulationResult } from '@naculus/wallet-engine';
+export { ApprovalChange, BalanceChange, GasInfo, RiskAssessment, RiskLevel, RiskWarning, SimulationResult, SimulationStatus } from '@naculus/wallet-engine';
+import * as React from 'react';
+import React__default from 'react';
+import { SiwxResult, SiwxSession } from '@naculus/siwx';
+import { StencilReactComponent, EventName } from '@stencil/react-output-target/runtime';
+import { AppkitAccordionCustomEvent, AppkitAlertDialogCustomEvent, AppkitCheckboxCustomEvent, AppkitCollapsibleCustomEvent, AppkitConnectButtonCustomEvent, AppkitDialogCustomEvent, AppkitDropdownMenuCustomEvent, AppkitInputCustomEvent, AppkitPopoverCustomEvent, AppkitSelectCustomEvent, AppkitSwitchCustomEvent, AppkitTabsCustomEvent, AppkitToggleGroupCustomEvent } from '@naculus/connect-appkit-wc';
+import { Components } from '@naculus/connect-appkit-wc/dist/components';
+import { AppkitAccordion as AppkitAccordion$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-accordion.js';
+import { AppkitAccountButton as AppkitAccountButton$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-account-button.js';
+import { AppkitAlertDialog as AppkitAlertDialog$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-alert-dialog.js';
+import { AppkitAvatar as AppkitAvatar$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-avatar.js';
+import { AppkitBadge as AppkitBadge$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-badge.js';
+import { AppkitButton as AppkitButton$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-button.js';
+import { AppkitCardContent as AppkitCardContent$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card-content.js';
+import { AppkitCardDescription as AppkitCardDescription$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card-description.js';
+import { AppkitCardFooter as AppkitCardFooter$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card-footer.js';
+import { AppkitCardHeader as AppkitCardHeader$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card-header.js';
+import { AppkitCardTitle as AppkitCardTitle$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card-title.js';
+import { AppkitCard as AppkitCard$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-card.js';
+import { AppkitCheckbox as AppkitCheckbox$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-checkbox.js';
+import { AppkitCollapsible as AppkitCollapsible$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-collapsible.js';
+import { AppkitConnectButton as AppkitConnectButton$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-connect-button.js';
+import { AppkitDialog as AppkitDialog$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-dialog.js';
+import { AppkitDropdownMenu as AppkitDropdownMenu$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-dropdown-menu.js';
+import { AppkitInput as AppkitInput$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-input.js';
+import { AppkitPopover as AppkitPopover$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-popover.js';
+import { AppkitProgress as AppkitProgress$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-progress.js';
+import { AppkitScrollArea as AppkitScrollArea$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-scroll-area.js';
+import { AppkitSelect as AppkitSelect$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-select.js';
+import { AppkitSeparator as AppkitSeparator$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-separator.js';
+import { AppkitSkeleton as AppkitSkeleton$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-skeleton.js';
+import { AppkitSwitch as AppkitSwitch$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-switch.js';
+import { AppkitTabs as AppkitTabs$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-tabs.js';
+import { AppkitToggleGroup as AppkitToggleGroup$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-toggle-group.js';
+import { AppkitTooltip as AppkitTooltip$1 } from '@naculus/connect-appkit-wc/dist/components/appkit-tooltip.js';
+import '@naculus/connector-passkeys';
+import '@naculus/connector-walletconnect';
+
+/**
+ * useCompareCosts — React hook for comparing operation costs across chains.
+ *
+ * Provides reactive state for comparing gas costs, fees, and estimated
+ * times for a given operation across multiple chains.
+ *
+ * @example
+ * ```tsx
+ * import { useCompareCosts } from "@naculus/connect-appkit-react";
+ *
+ * function CostComparisonPanel() {
+ *   const { comparisons, loading, error, refresh } = useCompareCosts({
+ *     operation: "send_erc20",
+ *     chains: ["eip155:1", "eip155:137", "eip155:10"],
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {comparisons.map(c => (
+ *         <div key={c.chain}>
+ *           {c.chainName}: ${c.totalCost} (gas: ${c.gasCost})
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+interface CostComparison {
+    chain: string;
+    chainName: string;
+    totalCost: string;
+    gasCost: string;
+    estimatedTimeMs: number;
+}
+type CostComparisonOperation = "send_erc20" | "swap" | "bridge" | (string & {});
+interface CostComparisonOptions {
+    amount?: string;
+    token?: string;
+    [key: string]: unknown;
+}
+interface UseCompareCostsInput {
+    operation: CostComparisonOperation;
+    chains: string[];
+    options?: CostComparisonOptions;
+}
+interface UseCompareCostsReturn {
+    /** Sorted cost comparisons (cheapest first) */
+    comparisons: CostComparison[];
+    /** Whether a comparison request is in flight */
+    loading: boolean;
+    /** Error that occurred during the last request */
+    error: Error | null;
+    /** Manually trigger a refresh */
+    refresh: () => Promise<void>;
+}
+declare function useCompareCosts(input: UseCompareCostsInput, compareCostsFn?: (operation: string, chains: string[], options?: CostComparisonOptions) => Promise<CostComparison[]>): UseCompareCostsReturn;
+
+/**
+ * useExecuteRoute — React hook for executing cross-chain routes.
+ *
+ * Manages the execution lifecycle of a cross-chain transfer.
+ * Tracks execution status, bridge reference, and completion state.
+ *
+ * @example
+ * ```tsx
+ * import { useExecuteRoute } from "@naculus/connect-appkit-react";
+ *
+ * function RouteExecutionPanel({ quote }) {
+ *   const { execute, executing, result, error } = useExecuteRoute();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => execute(quote, "0xRecipient")} disabled={executing}>
+ *         {executing ? "Executing..." : "Execute Route"}
+ *       </button>
+ *       {result && <div>Tx: {result.fromTxHash}</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+interface Quote$1 {
+    routeId: string;
+    provider: string;
+    totalCost?: bigint;
+    estimatedTimeMs?: number;
+    /**
+     * CAIP-2 chain the funds arrive on.
+     *
+     * Optional, and the only thing that makes `recipient` checkable. Without it
+     * this hook cannot know whether "0x…" or a base58 string is the right shape,
+     * so it does not guess — an EVM-looking check here would reject every
+     * legitimate Solana and XRPL recipient. Supply it and the recipient is
+     * validated for that namespace before anything is sent.
+     *
+     * Note that `Quote` as exported from the package root is `useRouteQuote`'s
+     * type, which has different fields. A quote from that hook satisfies this
+     * one structurally, so `totalCost` and `estimatedTimeMs` arrive undefined
+     * and `toChain` has to be supplied by the caller.
+     */
+    toChain?: string;
+}
+interface ExecuteRouteResult {
+    fromTxHash: string;
+    toTxHash?: string;
+}
+interface ExecuteOptions {
+    timeoutMs?: number;
+    gasLimit?: bigint;
+}
+interface UseExecuteRouteReturn {
+    /**
+     * Execute a route. Resolves with the result, or null if it failed.
+     *
+     * The result is returned as well as stored because `result` on this object
+     * belongs to the render that produced it: a caller awaiting `execute` cannot
+     * read it, and for a cross-chain transfer "did the funds move" is not a
+     * question to answer on the next render.
+     */
+    execute: (quote: Quote$1, recipient: string, options?: ExecuteOptions) => Promise<ExecuteRouteResult | null>;
+    /** Whether execution is in progress */
+    executing: boolean;
+    /** The execution result (populated after successful execution) */
+    result: ExecuteRouteResult | null;
+    /** Error that occurred during execution */
+    error: ExecuteError | null;
+    /** Reset execution state back to initial */
+    reset: () => void;
+}
+interface ExecuteError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Hook for executing a cross-chain route.
+ *
+ * Manages the full lifecycle from calling executeRoute to
+ * tracking the result. For auto-approve flows, handles the
+ * approve → cross-chain sequence.
+ *
+ * @param executeRouteFn - Function that performs the actual route execution
+ */
+declare function useExecuteRoute(executeRouteFn?: (quote: Quote$1, recipient: string, options?: ExecuteOptions) => Promise<ExecuteRouteResult>): UseExecuteRouteReturn;
+
+/**
+ * useRouteQuote — React hook for cross-chain route quoting.
+ *
+ * Provides reactive state for discovering routes and getting quotes
+ * from the RouteEngine. Returns loading, error, and result states.
+ *
+ * @example
+ * ```tsx
+ * import { useRouteQuote } from "@naculus/connect-appkit-react";
+ *
+ * function QuotePanel() {
+ *   const { quotes, loading, error, refresh } = useRouteQuote({
+ *     fromChain: "eip155:1",
+ *     toChain: "eip155:137",
+ *     fromToken: "USDC",
+ *     amount: "1000000",
+ *   });
+ *
+ *   if (loading) return <div>Loading quotes...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {quotes.map(q => (
+ *         <div key={q.routeId}>
+ *           {q.provider} — {q.netReceiveFormatted} {q.toTokenSymbol}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+interface Quote {
+    routeId: string;
+    provider: string;
+    netReceiveFormatted: string;
+    toTokenSymbol: string;
+}
+interface QuoteOptions {
+    sortBy?: "cost" | "time" | "balance";
+    maxSlippage?: number;
+}
+interface UseRouteQuoteInput {
+    fromChain: string;
+    toChain: string;
+    fromToken: string;
+    toToken?: string;
+    amount: string;
+    options?: QuoteOptions;
+}
+interface UseRouteQuoteReturn {
+    /** Current list of quotes (sorted by options.sortBy) */
+    quotes: Quote[];
+    /** Whether a quote request is in flight */
+    loading: boolean;
+    /** Error that occurred during the last request */
+    error: Error | null;
+    /** Manually trigger a refresh (re-fetches quotes) */
+    refresh: () => Promise<void>;
+    /** Clear the current quotes and error state */
+    clear: () => void;
+}
+/**
+ * Hook for fetching cross-chain route quotes.
+ *
+ * Automatically re-fetches when input parameters change.
+ * Debounces rapid changes to avoid excessive API calls.
+ *
+ * @param input - Quote request parameters
+ * @param getQuoteFn - Function that performs the actual quote fetch
+ */
+declare function useRouteQuote(input: UseRouteQuoteInput, getQuoteFn?: (from: string, to: string, token: string, amount: string, options?: QuoteOptions, 
+/**
+ * Destination token for a cross-token route. Appended so existing
+ * implementations stay assignable; `toToken` was declared on the input and
+ * then dropped, so a USDC→USDT quote silently asked for USDC→USDC.
+ */
+toToken?: string) => Promise<Quote[]>): UseRouteQuoteReturn;
+
+interface AccountEntry {
+    /** As the session reports it: CAIP-10 for most wallets, bare hex for some. */
+    address: string;
+    /** The namespace, when the entry was CAIP-10. Null for a bare address. */
+    namespace: string | null;
+    isEVM: boolean;
+}
+/**
+ * The connected accounts, split by what they actually are.
+ *
+ * Reads the namespace from the CAIP-10 form rather than inferring it from
+ * address shape wherever it can, and falls back to shape only for a bare
+ * address. A bare 0x-40-hex value is unambiguously EVM; a bare base58 string
+ * is not unambiguously anything.
+ */
+declare function useAccount(): {
+    accounts: AccountEntry[] | null;
+    evmAccount: string | null;
+    primaryAccount: string;
+    isConnected: boolean;
+    count: number;
+};
+
+/** SIWx (Sign-In With X) CAIP-122 configuration */
+interface SIWxConfig {
+    /** Called after wallet connects to build the message to sign */
+    createMessage: (params: {
+        address: string;
+        chainId: string;
+    }) => Promise<string>;
+    /** Called after the user signs the message */
+    handleSignComplete?: (params: {
+        message: string;
+        signature: string;
+    }) => Promise<void>;
+    /** Whether SIWx is required. If true, wallet disconnects on sign failure (default: true) */
+    required?: boolean;
+    /**
+     * Whether an authenticated session already exists, asked on reconnect.
+     *
+     * `autoConnect` restores a stored wallet session on every page load, and
+     * that path used to report `connected` without SIWx ever running — so
+     * `required: true`, the strongest setting, was enforced on first connect
+     * and skipped on every refresh afterwards.
+     *
+     * Reconnect now re-authenticates when SIWx is required. Supply this to say
+     * "the user is already signed in, do not prompt again": return true from
+     * your own session check — `useSIWxSession` tracks expiry for exactly this.
+     *
+     * Absent means unknown, and unknown re-authenticates. A signature prompt is
+     * a nuisance; treating an unverified session as signed in is not.
+     */
+    hasValidSession?: () => boolean | Promise<boolean>;
+}
+interface Web3ConnectConfig {
+    projectId: string;
+    metadata: {
+        name: string;
+        description: string;
+        url: string;
+        icons: string[];
+    };
+    chains?: WalletChain[];
+    /** SIWx (Sign-In With X) post-connection authentication */
+    siwx?: SIWxConfig;
+    storageKey?: string;
+    /** Enable embedded self-custodial wallet */
+    enableEmbedded?: boolean;
+    /** Configuration forwarded to the embedded wallet engine. */
+    embeddedConfig?: PocketConfig;
+    /** Enable passkeys (WebAuthn) connector */
+    enablePasskeys?: boolean;
+    /** Enable Solana injected wallet connector (Phantom, Solflare) */
+    enableSolana?: boolean;
+    /** Default Solana chain for injected wallet connections (e.g. "solana:0"). */
+    solanaDefaultChain?: string;
+    /** Connection timeout in milliseconds (default: 30000) */
+    connectionTimeout?: number;
+    /** Max retry attempts for reconnection (default: 2) */
+    maxRetries?: number;
+    /** Refresh fee data after a chain switch (default: true). */
+    autoRefreshFeeOnSwitch?: boolean;
+    /**
+     * Optional AES-256-GCM encryption key for session persistence.
+     * When provided, session data is encrypted at rest in localStorage. This
+     * key is frontend runtime data, not a secret boundary; never use a PaaS
+     * root credential, signing key, or private API token here.
+     * When omitted, existing backward-compatible plaintext storage is used.
+     */
+    encryptionKey?: string;
+}
+interface Web3Actions {
+    startPairing: () => Promise<string>;
+    /**
+     * Abandon an in-flight pairing.
+     *
+     * WalletConnect cannot withdraw a proposal once the URI is displayed, so
+     * this refuses the resulting session and disconnects it if the wallet
+     * approves anyway. A user who cancels must not end up connected.
+     */
+    cancelPairing: () => void;
+    completePairing: () => Promise<UniversalWalletSession>;
+    connect: () => Promise<void>;
+    connectInjected: (walletId?: string) => Promise<void>;
+    /** Connect via embedded self-custodial wallet */
+    connectEmbedded: () => Promise<void>;
+    /** Connect via passkeys (WebAuthn) */
+    connectPasskeys: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    reconnect: () => Promise<void>;
+    switchChain: (chainId: string) => Promise<void>;
+    /** Clear the current error state without triggering reconnection */
+    clearError: () => void;
+}
+interface UseWalletReturn extends Web3State, Web3Actions {
+}
+type EvmTransaction = {
+    to: string;
+    from?: string;
+    value?: string;
+    data?: string;
+    gas?: string;
+    gasPrice?: string;
+    nonce?: string;
+    chainId?: number;
+};
+
+interface UseBalanceOptions {
+    /** Auto-refresh interval in milliseconds. Default: undefined (no auto-refresh). */
+    refreshInterval?: number;
+}
+interface UseBalanceResult {
+    /** Raw balance in wei (string), or null if not connected / error */
+    balance: string | null;
+    /** Human-readable formatted balance in ETH (or native token), or null */
+    formatted: string | null;
+    /** Native token symbol (e.g. "ETH", "MATIC") */
+    /**
+     * The native currency symbol, or null when it is not known.
+     *
+     * Null rather than "ETH". This is rendered beside the number, so a fallback
+     * labels 1.5 MATIC or 1.5 SOL as ether. Show the amount without a unit, or
+     * hide it, but do not name the wrong one.
+     */
+    symbol: string | null;
+    /** USD price of one native token, or null if unavailable */
+    usdPrice: number | null;
+    /** Formatted USD value of the balance (e.g. "$1,234.56"), or null */
+    usdValue: string | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    chain: WalletChain | null;
+}
+declare function useBalance(options?: UseBalanceOptions): UseBalanceResult;
+
+/**
+ * Whether a wallet can execute a batch atomically.
+ *
+ * Three values, not two. A wallet that does not implement
+ * `wallet_getCapabilities` has not said no — it has said nothing, and EIP-5792
+ * is explicit that absence is not a denial. Collapsing that into `false` sends
+ * every such wallet down the sequential path, which is the one where an
+ * approve can land and the swap it was for can fail.
+ */
+type AtomicSupport = "supported" | "unsupported" | "unknown";
+interface ChainCapabilities {
+    /** CAIP-2 chain this describes. */
+    chainId: string;
+    atomic: AtomicSupport;
+    /** Largest batch the wallet will accept, when it says. */
+    maxBatchSize?: number;
+    /** The raw entry, for capabilities this SDK does not model. */
+    raw: WalletCapabilities;
+}
+interface UseCapabilitiesReturn {
+    /** Per-chain, keyed by CAIP-2. Null until a query has actually returned. */
+    capabilities: Record<string, ChainCapabilities> | null;
+    /** The connected chain's entry, for the common case. */
+    current: ChainCapabilities | null;
+    /**
+     * Atomic support on the connected chain.
+     *
+     * `"unknown"` while loading, when the wallet does not implement the method,
+     * and when the query failed — all three are "we have not been told", and a
+     * caller deciding between an atomic and a sequential path needs to know that
+     * rather than be handed a confident `false`.
+     */
+    atomic: AtomicSupport;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * What the connected wallet says it can do — EIP-5792
+ * `wallet_getCapabilities`.
+ *
+ * This is the query a dApp makes *before* choosing how to execute: ask whether
+ * the wallet batches atomically, then send one batch or a sequence, rather
+ * than sending a batch and discovering the answer from a rejection.
+ */
+declare function useCapabilities(): UseCapabilitiesReturn;
+
+/**
+ * The connected chain, and the chains it is possible to switch to.
+ *
+ * All the judgement lives in `core/chain-selection.ts`, which imports no
+ * framework — the Vue binding for this is the same three calls.
+ */
+declare function useChain(): {
+    chainId: string | null;
+    currentChain: WalletChain | null;
+    chainInfo: ChainInfo | null;
+    availableChains: WalletChain[];
+    chains: WalletChain[];
+    isEvm: boolean;
+    switchChain: (chainId: string) => Promise<void>;
+};
+
+declare function useConnect(): {
+    connect: () => Promise<void>;
+    isConnecting: boolean;
+    error: Error | null;
+};
+
+interface UseDelegationReturn extends DelegationStatus {
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Whether the connected EOA currently delegates to contract code — EIP-7702.
+ *
+ * A delegated account executes like a contract account: it can run several
+ * calls in one transaction, which is the thing that decides whether batching
+ * is possible at all for an ordinary address.
+ *
+ * `delegated` is `null` until the code has actually been read, and stays null
+ * when the read fails. That is not the same as `false`: treating a failed RPC
+ * as "no delegation" is how an account that can batch gets sent down the path
+ * for one that cannot.
+ */
+declare function useDelegation(): UseDelegationReturn;
+
+/** Which executor actually runs the calls. */
+type ExecutionRoute = "wallet-batch" | "user-operation" | "sequential";
+interface ExecutionPreview extends ExecutionPlan {
+    route: ExecutionRoute | null;
+}
+interface UseExecuteCallsOptions {
+    /** Default requirement for `execute`. Per-call override is also accepted. */
+    atomicity?: AtomicityRequirement;
+    /**
+     * Whether gas must be covered by a paymaster.
+     *
+     * A separate axis from atomicity: it answers who pays, not whether the calls
+     * land together, and either can end in a refusal on its own. A route that
+     * executes perfectly but charges a user who was promised sponsored gas is
+     * still the wrong route, and signing is too late to find out.
+     */
+    sponsorship?: AtomicityRequirement;
+    /**
+     * ERC-7677 service passed to `wallet_sendCalls` when the wallet advertises
+     * paymaster support. Advertising support alone does not sponsor a call: the
+     * service URL (and optional context) is the executable configuration.
+     */
+    paymasterService?: {
+        url: string;
+        context?: Record<string, unknown>;
+    };
+    /**
+     * A smart-account executor, typically `sendUserOp` from
+     * `useSendUserOperation`.
+     *
+     * A UserOperation carries its calls in one on-chain execution, so it is
+     * atomic by construction. Supplying this gives a wallet that cannot batch a
+     * route that still satisfies `"required"` instead of a refusal.
+     */
+    userOperation?: (calls: BatchCall[]) => Promise<string>;
+    /** Whether the supplied UserOperation executor is configured to sponsor gas. */
+    userOperationSponsored?: boolean;
+}
+interface UseExecuteCallsReturn {
+    /**
+     * What would happen for this many calls, without sending anything.
+     *
+     * This is the query EIP-5792 exists for. An application can show "these two
+     * will land together" or "these will be sent one by one" before the user
+     * commits, rather than discovering it from a half-executed batch.
+     */
+    preview: (callCount: number, atomicity?: AtomicityRequirement) => ExecutionPreview;
+    execute: (calls: BatchCall[], atomicity?: AtomicityRequirement) => Promise<string>;
+    isExecuting: boolean;
+    error: Error | null;
+    /** The route the last `execute` took. */
+    lastRoute: ExecutionRoute | null;
+    reset: () => void;
+}
+/**
+ * Route a set of calls to whichever executor can honour the caller's
+ * atomicity requirement — and refuse when none can.
+ *
+ * `useSendCalls` already picks between an EIP-5792 batch and a sequential
+ * fallback, but it picks silently and always sends something. A caller that
+ * batched an approve with the swap it pays for cannot tell the difference
+ * between "these landed together" and "the approve landed and the swap did
+ * not", which is the outcome that leaves an approval standing to a contract
+ * the user never transacted with.
+ */
+declare function useExecuteCalls(options?: UseExecuteCallsOptions): UseExecuteCallsReturn;
+
+interface DelegationPolicyPreview {
+    policy: SessionKeyInfo | null;
+    scope: ScopeCheckResult;
+    execution: ExecutionPreview;
+    signerMatches: boolean;
+    /** The stored signature still matches the persisted scope, signer, and origin. */
+    authorizationVerified: boolean;
+    /** Policy and route preflight passed; this does not imply broadcast. */
+    ready: boolean;
+    /** False until a session-signature-aware AA/7702 broadcaster is attached. */
+    broadcastReady: boolean;
+    /** The concrete on-chain route, when one has proved the policy is installed. */
+    broadcastRoute: PolicyExecutionRoute | null;
+    /** Whether that route has verified on-chain authorization for this policy. */
+    onchainAuthorizationVerified: boolean;
+    /** Guaranteed gas payer status for the configured broadcast route. */
+    broadcastSponsored: boolean | null;
+    /** Whether submission can proceed without invoking the main wallet again. */
+    broadcastPromptless: boolean;
+    reason: string;
+}
+type PolicyExecutionRoute = "erc4337" | "eip7702";
+interface PolicyExecutionCheck {
+    /** True only after the adapter has checked its live account/module state. */
+    ready: boolean;
+    /** True only when the session policy is enforceable by the target account. */
+    authorizationInstalled: boolean;
+    /** Whether this route guarantees the user will not pay gas. */
+    sponsored: boolean;
+    /** True only when submission does not invoke the main wallet again. */
+    promptless: boolean;
+    /** EIP-7702 delegate observed/configured by the adapter. */
+    executorAddress?: `0x${string}`;
+    reason: string;
+}
+interface PreparedPolicyExecution {
+    /** Exact digest the configured account/module validates on chain. */
+    digest: Hex;
+    /** Authoritative facts used for the final locked policy check. */
+    transaction: SessionKeyTransaction;
+    /** Adapter-private payload passed back unchanged for submission. */
+    payload: unknown;
+}
+interface PolicyExecutionSubmission {
+    route: PolicyExecutionRoute;
+    /** UserOperation hash for ERC-4337, transaction hash for EIP-7702. */
+    hash: Hex;
+    /** A hash proves submission, not inclusion. */
+    status: "submitted";
+}
+/**
+ * Account-specific bridge between a signed Naculus policy and on-chain code.
+ *
+ * ERC-4337 does not standardize session keys, and EIP-7702 only delegates code;
+ * the selected account/module still defines the signature envelope and policy
+ * storage. The adapter therefore has to prove that authorization is installed,
+ * prepare the exact digest that code validates, and broadcast that same payload.
+ */
+interface PolicyExecutionAdapter {
+    route: PolicyExecutionRoute;
+    check: (request: {
+        policy: SessionKeyInfo;
+        transaction: SessionKeyTransaction;
+    }) => Promise<PolicyExecutionCheck>;
+    prepare: (request: {
+        policy: SessionKeyInfo;
+        transaction: SessionKeyTransaction;
+    }) => Promise<PreparedPolicyExecution>;
+    broadcast: (request: {
+        policy: SessionKeyInfo;
+        prepared: PreparedPolicyExecution;
+        signature: Hex;
+    }) => Promise<PolicyExecutionSubmission>;
+}
+interface UseDelegationPolicyOptions {
+    /** Must include a host-provided encryptionKey before a policy can be created. */
+    managerConfig?: SessionKeyManagerConfig;
+    execution?: UseExecuteCallsOptions;
+    /** Domain shown in the signed policy. Defaults to the browser origin. */
+    origin?: string;
+    /** Concrete AA-module or EIP-7702 executor for promptless submissions. */
+    adapter?: PolicyExecutionAdapter;
+}
+interface UseDelegationPolicyReturn {
+    policies: SessionKeyInfo[];
+    /** Active policies whose persisted signature still verifies. */
+    activePolicies: SessionKeyInfo[];
+    storageAvailable: boolean;
+    loading: boolean;
+    isBusy: boolean;
+    error: Error | null;
+    delegation: ReturnType<typeof useDelegation>;
+    createPolicy: (scope: Partial<SessionKeyScope>) => Promise<SessionKeyInfo>;
+    revokePolicy: (policyId: string) => Promise<void>;
+    previewPolicyExecution: (policyId: string, tx: SessionKeyTransaction, callCount?: number, atomicity?: AtomicityRequirement) => Promise<DelegationPolicyPreview>;
+    /**
+     * Sign one 32-byte execution digest after enforcing the persisted policy.
+     * This returns a signature only; an AA/7702 adapter must still broadcast it.
+     */
+    signPolicyDigest: (policyId: string, digest: `0x${string}`, tx: SessionKeyTransaction) => Promise<`0x${string}`>;
+    /** Prepare, policy-check, session-sign, and submit one exact operation. */
+    executePolicy: (policyId: string, tx: SessionKeyTransaction) => Promise<PolicyExecutionSubmission>;
+    refresh: () => Promise<void>;
+    clearError: () => void;
+}
+/** Build the exact, deterministic message the main wallet authorizes. */
+declare function buildDelegationPolicyMessage(policy: SessionKeyInfo, origin: string): string;
+/**
+ * Complete product flow for local, signed, persistent session policies.
+ *
+ * This intentionally supports `offchain` mode only. Creating an EIP-7702 or
+ * AA-module policy requires a real on-chain executor; accepting those modes
+ * here would turn a local record into a false delegation claim.
+ */
+declare function useDelegationPolicy(options?: UseDelegationPolicyOptions): UseDelegationPolicyReturn;
+
+declare function useDisconnect(): {
+    disconnect: () => Promise<void>;
+    isDisconnecting: boolean;
+    error: Error | null;
+    cleanup: () => void;
+};
+
+/** Public account metadata. Signing material never enters React state. */
+type EmbeddedWalletAccountView = Omit<WalletAccount, "privateKey">;
+/**
+ * Public wallet metadata safe to render or pass through application state.
+ *
+ * `WalletData` is deliberately still returned by explicit create/import
+ * calls because those are recovery workflows. The long-lived `wallet` state
+ * must never retain the mnemonic or account private keys.
+ */
+interface EmbeddedWalletView {
+    accounts: EmbeddedWalletAccountView[];
+    activeNamespace: WalletNamespace;
+    createdAt: number;
+    chainId?: string;
+    version?: 2;
+    /** Whether the stored record can derive missing namespace accounts. */
+    recoveryAvailable: boolean;
+    readonly address?: string;
+}
+interface UseEmbeddedWalletReturn {
+    connectEmbedded: () => Promise<void>;
+    /** Load an existing wallet without creating or connecting a new one. */
+    restoreWallet: () => Promise<boolean>;
+    generateWallet: () => Promise<WalletData | null>;
+    importFromMnemonic: (mnemonic: string) => Promise<WalletData | null>;
+    /**
+     * Import a raw key in whatever form the user has it.
+     *
+     * Accepts the forms MetaMask, Phantom and `solana-keygen` export, and works
+     * out which chain it belongs to rather than asking. Only that namespace is
+     * enabled: a key is on exactly one curve, so an account for the other would
+     * be an address the key cannot control and the user cannot recover.
+     */
+    importFromPrivateKey: (pk: string) => Promise<WalletData | null>;
+    wipe: () => Promise<void>;
+    wallet: EmbeddedWalletView | null;
+    hasWallet: boolean;
+    /** The active account's address. See `accounts` for the rest. */
+    address: string | null;
+    /**
+     * Every account this wallet holds, one per namespace.
+     *
+     * A phrase derives an independent key per BIP-44 coin type, so a wallet
+     * created from one holds both an EVM and a Solana account. They are not
+     * variants of one key — holding one does not reveal the other.
+     */
+    accounts: EmbeddedWalletAccountView[];
+    /** Which account signs when no namespace is named. */
+    activeNamespace: WalletNamespace | null;
+    /**
+     * Choose which account signs.
+     *
+     * Rejects a namespace this wallet holds no account for, rather than leaving
+     * it pointing at nothing — a wallet imported from a raw key has only the
+     * namespace that key belongs to.
+     */
+    setActiveNamespace: (namespace: WalletNamespace) => void;
+    /**
+     * Derive accounts the phrase produces but this record does not yet hold.
+     *
+     * A wallet created before multi-namespace support already owns its Solana
+     * account — the same phrase in Phantom shows the balance — so this makes it
+     * visible here rather than leaving funds reachable everywhere except in this
+     * app. Leaves the active namespace alone: someone who had an Ethereum wallet
+     * yesterday should not find themselves on Solana today.
+     */
+    backfillAccounts: () => Promise<EmbeddedWalletAccountView[]>;
+    /** @deprecated Use getSeedPhrase() instead. This field will be removed. */
+    seedPhrase: string | null;
+    /** Get seed phrase once and clear from memory. Returns mnemonic or null. */
+    getSeedPhrase: () => string | null;
+    /** Read the active private key only for an explicit backup/export action. */
+    getPrivateKey: () => string | null;
+    backupPending: boolean;
+    confirmBackup: () => void;
+    isBusy: boolean;
+    error: Error | null;
+    clearError: () => void;
+    /**
+     * Storage security tier (1-4).
+     *   1 = IndexedDB + AES-GCM,  2 = IndexedDB,
+     *   3 = localStorage + AES-GCM, 4 = localStorage plaintext
+     */
+    storageSecurityLevel: number;
+    /**
+     * The same tier as a score with the findings behind it, or null before a
+     * wallet exists.
+     *
+     * Null rather than a worst-case report: the storage backend is chosen when
+     * the wallet is created, so warning about it beforehand would describe a
+     * state that has not happened.
+     */
+    securityReport: StorageSecurityReport | null;
+}
+declare function useEmbeddedWallet(): UseEmbeddedWalletReturn;
+
+interface UseERC20AllowanceOptions {
+    token: TokenConfig;
+    owner: Address;
+    spender: Address;
+    refreshInterval?: number;
+}
+interface UseERC20AllowanceReturn {
+    allowance: string | null;
+    allowanceRaw: bigint | null;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+declare function useERC20Allowance(options: UseERC20AllowanceOptions): UseERC20AllowanceReturn;
+
+interface UseERC20ApproveOptions {
+    token: TokenConfig;
+    spender: Address;
+}
+interface UseERC20ApproveReturn {
+    /** Approve a specific amount */
+    approve: (amount: string) => Promise<`0x${string}`>;
+    /** Approve max (type(uint256).max — infinite approval) */
+    approveMax: () => Promise<`0x${string}`>;
+    /** Current allowance as raw bigint */
+    allowanceRaw: bigint | null;
+    /** Current allowance as human-readable string */
+    allowance: string | null;
+    /** Check if allowance >= required amount */
+    hasAllowance: (required: string) => Promise<boolean>;
+    isApproving: boolean;
+    isFetchingAllowance: boolean;
+    error: Error | null;
+    /**
+     * Re-read the allowance and return it.
+     *
+     * The value is returned because reading `allowanceRaw` immediately after
+     * awaiting this does not work: that binding belongs to the render that
+     * created the callback, and setState does not rewrite it.
+     */
+    refetchAllowance: () => Promise<bigint | null>;
+}
+declare function useERC20Approve(options: UseERC20ApproveOptions): UseERC20ApproveReturn;
+
+interface UseERC20TransferOptions {
+    token: TokenConfig;
+}
+interface UseERC20TransferReturn {
+    /** Send a transfer. Returns tx hash on success. */
+    sendTransfer: (to: Address, amount: string) => Promise<`0x${string}`>;
+    isSending: boolean;
+    error: Error | null;
+}
+declare function useERC20Transfer(options: UseERC20TransferOptions): UseERC20TransferReturn;
+
+interface UseTransactionSimulationReturn {
+    /** Current simulation result (undefined until first run) */
+    result: SimulationResult | undefined;
+    /** Whether a simulation is in progress */
+    isSimulating: boolean;
+    /** Error from the last simulation attempt */
+    error: Error | null;
+    /** Manually trigger a simulation */
+    simulate: () => Promise<SimulationResult>;
+    /** Reset the simulation state */
+    reset: () => void;
+}
+declare function useTransactionSimulation(tx: EvmTransaction | undefined, chainId?: number): UseTransactionSimulationReturn;
+
+/**
+ * useERC20TransferSimulation — React hook for simulating ERC-20 token
+ *                              transfers before signing/submitting.
+ *
+ * Wraps useTransactionSimulation with ERC-20 transfer calldata building,
+ * so callers only need the token, recipient, and amount.
+ *
+ * @see /docs/features/transaction-simulation.md
+ */
+
+interface UseERC20TransferSimulationOptions {
+    /** Token configuration (address, decimals, chainId) */
+    token: TokenConfig;
+    /** Recipient address */
+    to: `0x${string}`;
+    /** Amount in human-readable units (e.g. "1.50" for 1.5 USDC) */
+    amount: string;
+}
+interface UseERC20TransferSimulationReturn extends Omit<UseTransactionSimulationReturn, "simulate"> {
+    /** Simulation result for the built ERC-20 transfer */
+    result: SimulationResult | undefined;
+    /** Whether a simulation is in progress */
+    isSimulating: boolean;
+    /** Error from the last simulation attempt */
+    error: Error | null;
+    /** Re-run the simulation with current parameters */
+    reSimulate: () => Promise<SimulationResult>;
+    /** Reset simulation state */
+    reset: () => void;
+}
+declare function useERC20TransferSimulation(options: UseERC20TransferSimulationOptions): UseERC20TransferSimulationReturn;
+
+type TxStatus = "pending" | "mined" | "confirmed" | "failed" | "unknown";
+interface TxStatusEntry {
+    hash: string;
+    chainId: number;
+    from: string;
+    to: string;
+    value: string;
+    data?: string;
+    nonce?: number;
+    status: TxStatus;
+    blockNumber?: number;
+    blockHash?: string;
+    gasUsed?: string;
+    effectiveGasPrice?: string;
+    createdAt: number;
+    confirmedAt?: number;
+    updatedAt: number;
+    error?: string;
+    label?: string;
+    memo?: string;
+    replacementCount?: number;
+}
+/** Minimal TxMonitor interface for React hooks */
+interface TxMonitorLike {
+    watchTx(hash: string, chainId: number, options?: {
+        requiredConfirmations?: number;
+        pollInterval?: number;
+        label?: string;
+        memo?: string;
+        initialEntry?: Partial<TxStatusEntry>;
+    }): Promise<TxStatusEntry>;
+    stopWatching(hash: string, chainId?: number): void;
+    getTxStatus(hash: string, chainId?: number): TxStatusEntry | null;
+    getTxHistory(address?: string, chainId?: number): Promise<TxStatusEntry[]>;
+    refreshTx(hash: string, chainId?: number): Promise<void>;
+    on(event: "statusChange", listener: (entry: TxStatusEntry) => void): this;
+    on(event: "confirmed", listener: (entry: TxStatusEntry) => void): this;
+    on(event: "failed", listener: (entry: TxStatusEntry) => void): this;
+    off(event: string, listener: Function): this;
+}
+declare const TxMonitorContext: React.Context<TxMonitorLike | null>;
+interface UseTxMonitorResult {
+    entry: TxStatusEntry | null;
+    status: TxStatus | "idle";
+    isLoading: boolean;
+    isWatching: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    stopWatching: () => void;
+}
+/**
+ * Monitor a single transaction's lifecycle.
+ * When hash changes, automatically stops old watch and starts new one.
+ */
+declare function useTxMonitor(hash?: string, chainId?: number, monitor?: TxMonitorLike): UseTxMonitorResult;
+
+interface UseLastTxResult {
+    /** Most recent transaction by createdAt */
+    lastTx: TxStatusEntry | null;
+    /** Most recent confirmed transaction */
+    lastConfirmedTx: TxStatusEntry | null;
+    /** Most recent failed transaction */
+    lastFailedTx: TxStatusEntry | null;
+    /** Clear cached lastTx state */
+    clear: () => void;
+}
+/**
+ * Track the most recent transaction.
+ * Automatically updates when a new transaction is sent (via statusChange events).
+ */
+declare function useLastTx(monitor?: TxMonitorLike): UseLastTxResult;
+
+/**
+ * Result of a reverse resolution query.
+ */
+interface UseLookupAddressResult {
+    /** Resolved name, or null if not found / not started. */
+    data: NameResult | null;
+    /** Whether the lookup is in progress. */
+    isLoading: boolean;
+    /** Error that occurred during lookup, if any. */
+    error: Error | null;
+    /** Manually trigger re-lookup of the current address. */
+    refetch: () => void;
+}
+/**
+ * Options for the useLookupAddress hook.
+ */
+interface UseLookupAddressOptions {
+    /** Chain to resolve against, CAIP-2. */
+    chainId?: string;
+    /** Whether to skip the lookup (e.g. if the input is incomplete). */
+    skip?: boolean;
+    /** Custom resolver configuration (overrides default RPC URLs). */
+    resolverConfig?: NameResolverConfig;
+}
+/**
+ * React hook to resolve a blockchain address to a human-readable name.
+ *
+ * Reverse resolution for ENS and SNS.
+ *
+ * @example
+ * ```tsx
+ * function AccountLabel({ address }) {
+ *   const { data } = useLookupAddress(address);
+ *   return <span>{data?.name ?? address}</span>;
+ * }
+ * ```
+ */
+declare function useLookupAddress(address: string, options?: UseLookupAddressOptions): UseLookupAddressResult;
+
+/**
+ * useNotification — React hook for push notification state.
+ *
+ * Provides notifications, settings, and control methods for the
+ * in-app notification center.
+ *
+ * @example
+ * ```tsx
+ * import { useNotification } from "@naculus/connect-appkit-react";
+ *
+ * function NotificationCenter() {
+ *   const { notifications, unreadCount, clear, markAsRead } = useNotification();
+ *   return (
+ *     <div>
+ *       <span>Unread: {unreadCount}</span>
+ *       <ul>
+ *         {notifications.map(n => (
+ *           <li key={n.id} onClick={() => markAsRead(n.id)}>
+ *             {n.title} — {n.body}
+ *           </li>
+ *         ))}
+ *       </ul>
+ *       <button onClick={clear}>Clear all</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+
+/**
+ * Hook for consuming in-app notifications in React components.
+ *
+ * Uses InAppChannel internally to manage the notification queue.
+ * All persistent state is stored via localStorage.
+ */
+declare function useNotification(options?: {
+    /** External InAppChannel instance (for sharing between hooks). If omitted, creates one. */
+    channel?: InAppChannel;
+    /** Custom storage for settings (defaults to localStorage) */
+    storage?: {
+        getItem: <T>(key: string) => Promise<T | null>;
+        setItem: <T>(key: string, value: T) => Promise<void>;
+        removeItem: (key: string) => Promise<void>;
+    };
+}): {
+    /** All in-app notifications (newest last) */
+    notifications: NotificationItem[];
+    /** Number of unread notifications */
+    unreadCount: number;
+    /** Add a single notification manually */
+    addNotification: (item: Omit<NotificationItem, "id" | "timestamp">) => void;
+    /** Clear all in-app notifications */
+    clear: () => void;
+    /** Clear a single notification */
+    clearOne: (id: string) => void;
+    /** Mark a notification as read */
+    markAsRead: (id: string) => void;
+    /** Mark all as read */
+    markAllAsRead: () => void;
+    /** Current notification settings */
+    settings: NotificationSettings;
+    /** Update notification settings */
+    updateSettings: (update: Partial<NotificationSettings>) => void;
+    /** Set active channels by id */
+    setChannels: (channels: string[]) => void;
+    /** Mute a chain */
+    muteChain: (chainId: string) => void;
+    /** Unmute a chain */
+    unmuteChain: (chainId: string) => void;
+};
+
+interface UsePassphraseGateReturn {
+    /**
+     * The open request, or null when nothing is being asked.
+     *
+     * Also null when no gate exists — an app that supplies its own
+     * `encryptionPassphrase`, or one with encryption off entirely. A dialog can
+     * render against this unconditionally.
+     */
+    request: PassphraseRequest | null;
+    /** Answer the open request. */
+    submit: (passphrase: string) => void;
+    /** Abandon it, failing the load or save that asked. */
+    cancel: () => void;
+    /** Drop the held passphrase, so the next operation asks again. */
+    forget: (reason?: string) => void;
+    /** Whether a passphrase is held for this session. */
+    isUnlocked: boolean;
+    gate: PassphraseGate | null;
+}
+/**
+ * Drives the passphrase prompt for the embedded wallet's encrypted storage.
+ *
+ * The gate belongs to the client, so a dialog mounted anywhere under the
+ * provider answers whichever load or save is currently blocked on it.
+ */
+declare function usePassphraseGate(): UsePassphraseGateReturn;
+
+/**
+ * Result of a name resolution query.
+ */
+interface UseResolveNameResult {
+    /** Resolved address, or null if not found / not started. */
+    data: AddressResult | null;
+    /** Whether the resolution is in progress. */
+    isLoading: boolean;
+    /** Error that occurred during resolution, if any. */
+    error: Error | null;
+    /** Manually trigger re-resolution of the current name. */
+    refetch: () => void;
+}
+/**
+ * Options for the useResolveName hook.
+ */
+interface UseResolveNameOptions {
+    /** Whether to skip resolution (e.g. if input is invalid). Default: false. */
+    skip?: boolean;
+    /** Custom resolver configuration (overrides default RPC URLs). */
+    resolverConfig?: NameResolverConfig;
+}
+/**
+ * React hook to resolve a human-readable name to a blockchain address.
+ *
+ * Supports ENS (.eth) and SNS (.sol) names.
+ * Automatically detects the name service from the suffix.
+ *
+ * @example
+ * ```tsx
+ * function AddressInput() {
+ *   const { data, isLoading, error } = useResolveName('vitalik.eth');
+ *   return <div>{data?.address ?? 'Enter a name'}</div>;
+ * }
+ * ```
+ */
+declare function useResolveName(name: string, options?: UseResolveNameOptions): UseResolveNameResult;
+
+/**
+ * Where a batch has got to.
+ *
+ * `"submitted"` was `"confirmed"`, which this hook is two steps away from
+ * knowing. `wallet_sendCalls` answers with a bundle identifier, and a bundle
+ * identifier does not even promise the calls were broadcast — EIP-5792 lets a
+ * wallet accept them and send later. The sequential fallback returns the last
+ * transaction hash, which promises broadcast and nothing more.
+ *
+ * `getCallsStatus` is what turns a bundle identifier into an outcome.
+ */
+type SendCallsStatus = "idle" | "awaiting_approval" | "submitted" | "failed";
+declare function useSendCalls(): {
+    sendCalls: (calls: BatchCall[], options?: {
+        chainId?: string;
+        strategy?: ExecutionStrategy;
+        paymasterService?: {
+            url: string;
+            context?: Record<string, unknown>;
+        };
+    }) => Promise<string>;
+    getCallsStatus: (hash?: string) => Promise<CallsStatus>;
+    showCallsStatus: (hash?: string) => Promise<boolean>;
+    status: SendCallsStatus;
+    error: Error | null;
+    batchHash: string | null;
+    callsStatus: CallsStatus | null;
+    /**
+     * How the last send was actually executed, or null before one runs.
+     *
+     * "sequential" means the calls were sent one at a time and are NOT atomic:
+     * an earlier call can land while a later one fails. Surfaced rather than
+     * hidden because a caller batching an approve + swap needs to know which
+     * guarantee it got.
+     */
+    execution: ExecutionStrategy | null;
+    reset: () => void;
+    isSending: boolean;
+};
+
+/**
+ * Where a send has got to.
+ *
+ * `"submitted"` was `"confirmed"`, which was a claim the hook could not
+ * support: `sendTransaction` resolves with a transaction hash, and a hash
+ * means the wallet broadcast it — not that it was mined, and not that it
+ * succeeded. An interface showing "confirmed" at that moment tells someone
+ * their payment went through while it can still revert or never be included.
+ *
+ * To reach an actual confirmation, watch the returned hash with
+ * `useTxMonitor`, where `"confirmed"` is established by a receipt.
+ */
+type SendTransactionStatus = "idle" | "awaiting_approval" | "submitted" | "failed";
+declare function useSendTransaction(): {
+    sendTransaction: (transaction: EvmTransaction) => Promise<string>;
+    status: SendTransactionStatus;
+    error: Error | null;
+    reset: () => void;
+    isSending: boolean;
+};
+
+/**
+ * useSendUserOperation
+ *
+ * React hook for sending ERC-4337 UserOperations.
+ * Uses the core SmartAccountManager so address derivation, deployment,
+ * nonce reads, gas estimation, signing, and bundler serialization stay on one
+ * implementation path.
+ */
+
+interface UseSendUserOperationOptions {
+    /** RPC URL for the target chain */
+    rpcUrl?: string;
+    /** Bundler RPC URL */
+    bundlerUrl?: string;
+    /** Chain ID (CAIP-2 format) */
+    chainId?: string;
+    /** EntryPoint contract address */
+    entryPoint?: Address$1;
+    /** Smart account implementation type (default: "simple") */
+    accountType?: "simple" | "light" | "kernel" | "safe";
+    /** Optional salt for deterministic smart account address */
+    salt?: bigint;
+    /** Override the connected EVM account as the smart account owner */
+    owner?: Address$1;
+    /**
+     * Optional signer for the UserOperation hash. A custom signer is assumed to
+     * apply the signature scheme selected by `signerMode`.
+     */
+    signer?: (hash: Hex) => Promise<Hex> | Hex;
+    /** Signature hash format expected by the account implementation */
+    signerMode?: "raw" | "eip191";
+}
+interface UseSendUserOperationReturn {
+    /** Send a UserOperation with the given calls */
+    sendUserOp: (calls: Call[], options?: SendUserOpOptions) => Promise<UserOperationResponse | null>;
+    /** The userOpHash from the last send */
+    userOpHash: Hex | null;
+    /** The receipt from the last UserOperation (null while pending) */
+    receipt: UserOperationReceipt | null;
+    /** Whether a UserOperation is currently being sent */
+    isPending: boolean;
+    /** Loading state for gas estimation and submission */
+    isEstimating: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for sending ERC-4337 UserOperations to a bundler.
+ *
+ * The connected EVM account is used as the smart-account owner. The hook uses
+ * the active wallet's raw `personal_sign` request for WalletConnect and
+ * injected wallets; embedded/passkey users must provide a raw-hash signer until
+ * those connectors expose one.
+ */
+declare function useSendUserOperation(options?: UseSendUserOperationOptions): UseSendUserOperationReturn;
+
+interface UseSessionReturn {
+    /** The raw wallet session (from the active bundle) */
+    session: ActiveSessionBundle["walletSession"] | null;
+    /** All chain sessions within the active bundle */
+    chainSessions: ChainSession[];
+    /** The currently active chain ID */
+    activeChainId: string | null;
+    /** Whether a wallet is connected */
+    isConnected: boolean;
+    /** The connector/wallet type (e.g., "eip6963", "walletconnect") */
+    connectorId: string | null;
+}
+declare function useSession(sessionManager?: _naculus_connect_core.SessionManager | null): UseSessionReturn;
+
+interface UseSessionKeysReturn {
+    /** All session keys (active, revoked, expired) */
+    sessions: SessionKeyInfo[];
+    /** Only active session keys */
+    activeSessions: SessionKeyInfo[];
+    /** Whether data is loading */
+    loading: boolean;
+    /** Error from last operation */
+    error: Error | null;
+    /** Refresh the session list from storage */
+    refresh: () => Promise<void>;
+    /** Clear any error */
+    clearError: () => void;
+    /** Whether the storage backend is available */
+    storageAvailable: boolean;
+}
+/**
+ * Hook to list and manage session keys.
+ *
+ * @example
+ * ```tsx
+ * const { sessions, activeSessions, refresh } = useSessionKeys();
+ * ```
+ */
+declare function useSessionKeys(config?: SessionKeyManagerConfig): UseSessionKeysReturn;
+interface UseCreateSessionKeyReturn {
+    /** Create a new session key */
+    createSessionKey: (scope?: Partial<SessionKeyScope>, signerAddress?: `0x${string}`) => Promise<SessionKeyInfo>;
+    /** The last created session key info */
+    lastCreated: SessionKeyInfo | null;
+    /** Whether creation is in progress */
+    isCreating: boolean;
+    /** Error from last creation */
+    error: Error | null;
+    /** Clear error */
+    clearError: () => void;
+}
+/**
+ * Hook to create new session keys.
+ *
+ * @example
+ * ```tsx
+ * const { createSessionKey, lastCreated, isCreating } = useCreateSessionKey();
+ *
+ * const handleCreate = async () => {
+ *   const session = await createSessionKey({
+ *     expiry: Math.floor(Date.now() / 1000) + 1800, // 30 min
+ *     maxTotalValue: parseEther("0.1"),
+ *   });
+ * };
+ * ```
+ */
+declare function useCreateSessionKey(config?: SessionKeyManagerConfig): UseCreateSessionKeyReturn;
+interface UseRevokeSessionReturn {
+    /** Revoke a session key by ID */
+    revokeSession: (sessionId: string) => Promise<void>;
+    /** Whether revoking is in progress */
+    isRevoking: boolean;
+    /** Error from last operation */
+    error: Error | null;
+    /** Clear error */
+    clearError: () => void;
+}
+/**
+ * Hook to revoke a session key.
+ *
+ * @example
+ * ```tsx
+ * const { revokeSession, isRevoking } = useRevokeSession();
+ * await revokeSession(sessionId);
+ * ```
+ */
+declare function useRevokeSession(config?: SessionKeyManagerConfig): UseRevokeSessionReturn;
+interface UseSendWithSessionReturn {
+    /** Sign a transaction hash after enforcing the transaction scope */
+    signWithSession: (sessionId: string, messageHash: `0x${string}`, tx: SessionKeyTransaction) => Promise<`0x${string}`>;
+    /** Check if a transaction is within a session's scope */
+    checkScope: (sessionId: string, tx: {
+        to?: string;
+        value?: string;
+        data?: string;
+        chainId?: number;
+        gas?: string;
+    }) => Promise<{
+        valid: boolean;
+        reason?: string;
+        remainingGas?: bigint;
+        remainingValue?: bigint;
+        remainingTxCount?: number;
+    }>;
+    /** Whether an operation is in progress */
+    isBusy: boolean;
+    /** Error from last operation */
+    error: Error | null;
+    /** Clear error */
+    clearError: () => void;
+}
+/**
+ * Hook to sign transactions using session keys and check scope.
+ *
+ * @example
+ * ```tsx
+ * const { signWithSession, checkScope } = useSendWithSession();
+ *
+ * const check = await checkScope(sessionId, tx);
+ * if (check.valid) {
+ *   const sig = await signWithSession(sessionId, messageHash, tx);
+ * }
+ * ```
+ */
+declare function useSendWithSession(config?: SessionKeyManagerConfig): UseSendWithSessionReturn;
+/**
+ * Reset the global session key manager (useful for testing / cleanup).
+ */
+declare function resetSessionKeyManager(): void;
+
+/**
+ * useSIWxLogin — Trigger a SIWx sign-in flow.
+ *
+ * A simplified hook for initiating wallet sign-in.
+ * Returns a `signIn()` function and loading/error state.
+ */
+
+interface UseSIWxLoginOptions {
+    /** Originating domain (default: window.location.host) */
+    domain?: string;
+    /** Human-readable statement */
+    statement?: string;
+    /** RFC 3986 URI (default: window.location.origin) */
+    uri?: string;
+    /** CAIP-2 chain ID (default: current chain from Web3 context) */
+    chainId?: string;
+    /** Session lifetime in seconds (default: 86400 = 24h) */
+    expirySeconds?: number;
+    /** URIs of resources the identity wishes to access */
+    resources?: string[];
+    /** CAIP-74 request ID */
+    requestId?: string;
+}
+interface UseSIWxLoginReturn {
+    /** Trigger the SIWx sign-in flow */
+    signIn: (options?: UseSIWxLoginOptions) => Promise<SiwxResult>;
+    /** Whether a sign-in is in progress */
+    isSigningIn: boolean;
+    /** Last sign-in error */
+    error: Error | null;
+    /** Clear the last error */
+    clearError: () => void;
+}
+declare function useSIWxLogin(): UseSIWxLoginReturn;
+
+/**
+ * useSIWxSession — Unified SIWx session management hook.
+ *
+ * Combines the sign-in flow with session persistence, expiry tracking,
+ * and automatic restoration. Replaces the older useSiwxAuthSession.
+ *
+ * Provides:
+ *  - signIn / signOut / refresh lifecycle
+ *  - Auto-restore from storage on mount
+ *  - isExpired / timeUntilExpiry query
+ *  - Loading/error state
+ */
+
+interface UseSIWxSessionOptions {
+    /** Storage key prefix (default: "naculus_") */
+    storagePrefix?: string;
+    /** Auto-restore session from storage on mount (default: true) */
+    autoRestore?: boolean;
+    /** Default chain ID when signing in (default: current chain from context) */
+    defaultChainId?: string;
+    /** Default session lifetime in seconds (default: 86400 = 24h) */
+    defaultExpirySeconds?: number;
+}
+interface UseSIWxSessionReturn {
+    /** The current SIWx session, or null */
+    session: SiwxSession | null;
+    /** Whether a valid session exists */
+    isAuthenticated: boolean;
+    /** Whether we're still checking persisted auth on mount */
+    isRestoring: boolean;
+    /** Whether a sign-in is in progress */
+    isSigningIn: boolean;
+    /** Whether the current session has expired */
+    isExpired: boolean;
+    /** Milliseconds until session expires, or null */
+    timeUntilExpiry: number | null;
+    /** Sign in with optional overrides */
+    signIn: (options?: UseSIWxLoginOptions) => Promise<SiwxSession>;
+    /** Sign out: clears session from memory and storage */
+    signOut: () => Promise<void>;
+    /** Refresh the current session */
+    refresh: () => Promise<SiwxSession>;
+    /** Last error */
+    error: Error | null;
+    /** Clear the last error */
+    clearError: () => void;
+}
+declare function useSIWxSession(options?: UseSIWxSessionOptions): UseSIWxSessionReturn;
+
+interface UseSignInWithXOptions {
+    domain?: string;
+    statement?: string;
+    uri?: string;
+    chainId?: string;
+    expirySeconds?: number;
+    resources?: string[];
+    requestId?: string;
+}
+interface UseSignInWithXReturn {
+    signIn: (options?: UseSignInWithXOptions) => Promise<SiwxResult>;
+    isSigningIn: boolean;
+    result: SiwxResult | null;
+    error: Error | null;
+    clearError: () => void;
+}
+declare function useSignInWithX(): UseSignInWithXReturn;
+
+interface UseSignInWithEthereumOptions extends UseSignInWithXOptions {
+}
+interface UseSignInWithEthereumReturn extends UseSignInWithXReturn {
+}
+declare function useSignInWithEthereum(): UseSignInWithEthereumReturn;
+
+declare function useSignMessage(): {
+    signMessage: (message: string) => Promise<string>;
+    isSigning: boolean;
+    error: Error | null;
+};
+
+/**
+ * useSimulateTransfer — React hook for simulating ERC-20 token transfers.
+ *
+ * Wraps SimulationManager.simulateERC20Transfer in a React hook with
+ * reactive state for loading, result, and error.
+ *
+ * @example
+ * ```tsx
+ * import { useSimulateTransfer } from "@naculus/connect-appkit-react";
+ *
+ * function SendForm({ token, to, amount }) {
+ *   const { result, simulate, loading } = useSimulateTransfer({
+ *     rpcUrl: "https://eth.llamarpc.com",
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => simulate(token, to, amount)} disabled={loading}>
+ *         Simulate Transfer
+ *       </button>
+ *       {result && <p>Result: {result.status}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+
+interface UseSimulateTransferOptions {
+    /** RPC URL for eth_call simulation */
+    rpcUrl?: string;
+    /** Default chain ID */
+    chainId?: number;
+}
+interface UseSimulateTransferReturn {
+    /** Current simulation result */
+    result: SimulationResult | null;
+    /** Whether a simulation is in progress */
+    loading: boolean;
+    /** Last error (null if no error) */
+    error: Error | null;
+    /**
+     * Simulate an ERC-20 transfer.
+     *
+     * @param tokenAddress - ERC-20 token contract address
+     * @param from - Sender address
+     * @param to - Recipient address
+     * @param amount - Human-readable amount (e.g. "1.50")
+     * @param options - Optional chainId, rpcUrl, decimals override
+     */
+    simulate: (tokenAddress: `0x${string}`, from: `0x${string}`, to: `0x${string}`, amount: string, options?: {
+        chainId?: number;
+        rpcUrl?: string;
+        decimals?: number;
+    }) => Promise<SimulationResult>;
+    /** Reset result and error state */
+    reset: () => void;
+}
+/**
+ * Hook for simulating an ERC-20 token transfer.
+ *
+ * Creates a SimulationManager internally and provides a `simulate`
+ * function that builds transfer calldata automatically.
+ *
+ * @param options - Configuration for the underlying SimulationManager
+ */
+declare function useSimulateTransfer(options?: UseSimulateTransferOptions): UseSimulateTransferReturn;
+
+interface UseSiwxAuthSessionOptions {
+    /** Storage key prefix (default: "naculus_") */
+    storagePrefix?: string;
+    /** Auto-restore auth from storage on mount (default: true) */
+    autoRestore?: boolean;
+}
+interface UseSiwxAuthSessionReturn {
+    /** Whether a valid SIWx auth session exists */
+    isSignedIn: boolean;
+    /** Whether we're still checking persisted auth on mount */
+    isRestoring: boolean;
+    /** The persisted SIWx result, or null if not signed in */
+    siwxResult: SiwxResult | null;
+    /** Whether a sign-in is in progress */
+    isSigningIn: boolean;
+    /** Last sign-in error */
+    error: Error | null;
+    /** Sign in with optional overrides. Persists result to storage on success. */
+    signIn: (options?: UseSignInWithXOptions) => Promise<SiwxResult>;
+    /** Sign out: clears persisted auth and resets state */
+    signOut: () => void;
+    /** Clear the last error */
+    clearError: () => void;
+}
+declare function useSiwxAuthSession(options?: UseSiwxAuthSessionOptions): UseSiwxAuthSessionReturn;
+
+/**
+ * useSmartAccount
+ *
+ * React hook for ERC-4337 Smart Account lifecycle management.
+ * Provides create, deploy, and address lookup for smart contract wallets.
+ *
+ * @example
+ * ```tsx
+ * const { address, isDeployed, createWallet, deployWallet, isLoading } = useSmartAccount({
+ *   rpcUrl: "https://eth.llamarpc.com",
+ *   bundlerUrl: "https://api.pimlico.io/v2/1/rpc?apikey=...",
+ * });
+ * ```
+ */
+
+interface UseSmartAccountOptions {
+    /** RPC URL for the target chain */
+    rpcUrl?: string;
+    /** Bundler RPC URL */
+    bundlerUrl?: string;
+    /** Chain ID (CAIP-2 format) */
+    chainId?: string;
+    /** ERC-4337 EntryPoint address for the selected supported chain */
+    entryPoint?: Address$1;
+    /** Account type (default: "simple") */
+    accountType?: "simple" | "light" | "kernel" | "safe";
+    /** Optional salt for deterministic address */
+    salt?: bigint;
+}
+interface UseSmartAccountReturn {
+    /** Smart account address (null if not created) */
+    address: Address$1 | null;
+    /** Whether the account is deployed on-chain */
+    isDeployed: boolean;
+    /** Smart account info object */
+    accountInfo: SmartAccountInfo | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Create a new smart account (compute address) */
+    createWallet: () => Promise<SmartAccountInfo | null>;
+    /** Deploy the smart account to chain */
+    deployWallet: () => Promise<Address$1 | null>;
+    /** Get the counterfactual address without creating */
+    getAddress: () => Promise<Address$1 | null>;
+}
+/**
+ * Hook for managing a ERC-4337 Smart Contract Wallet lifecycle.
+ *
+ * @param options - Smart account configuration options
+ * @returns Smart account state and actions
+ */
+declare function useSmartAccount(options?: UseSmartAccountOptions): UseSmartAccountReturn;
+
+interface UseSolanaAccountReturn {
+    /** The bare base58 address, or null when no Solana account is connected. */
+    address: string | null;
+    /** The CAIP-10 form, which carries which cluster it is on. */
+    caip10: string | null;
+    /** The CAIP-2 cluster, e.g. `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`. */
+    chainId: string | null;
+    isConnected: boolean;
+}
+/**
+ * The connected Solana account, whichever wallet supplied it.
+ *
+ * Read off the session's namespaces rather than from the embedded connector,
+ * so an injected wallet (Phantom, Solflare) and the embedded wallet answer the
+ * same way.
+ *
+ * Matched on the `solana:` namespace, never on address shape. A base58 string
+ * is not distinguishable from other base58 strings by inspection, and guessing
+ * would eventually call something a Solana address that is not one.
+ */
+declare function useSolanaAccount(): UseSolanaAccountReturn;
+
+interface UseSolanaBalanceOptions {
+    /** Defaults to the connected Solana account. */
+    address?: string;
+    /** Defaults to the client's `solanaRpcUrl`. */
+    rpcUrl?: string;
+    /** Milliseconds between refreshes. Off by default. */
+    refreshInterval?: number;
+}
+interface UseSolanaBalanceReturn {
+    /** Null until a balance has actually been read. Never a fabricated zero. */
+    balance: SolanaBalance | null;
+    isFetching: boolean;
+    error: Error | null;
+    /** Absent when no RPC endpoint is configured — a different fact from a
+     *  balance of zero, and the only one a caller can act on. */
+    isConfigured: boolean;
+    refetch: () => Promise<void>;
+}
+/**
+ * The SOL balance of the connected Solana account.
+ *
+ * `balance` stays null until a read succeeds. A zero placeholder while
+ * loading, or after a failure, is a number a user reads as their balance.
+ */
+declare function useSolanaBalance(options?: UseSolanaBalanceOptions): UseSolanaBalanceReturn;
+
+interface UseSolanaTransactionReturn {
+    /**
+     * Sign a serialized transaction and return the signed bytes.
+     *
+     * Build and serialize it with `@solana/kit` or `@solana/web3.js` first —
+     * the wallet's job is the signature, not the instructions. base64 or raw
+     * bytes both work.
+     */
+    signTransaction: (transaction: Uint8Array | string) => Promise<Uint8Array>;
+    /** Sign and submit, returning the base58 signature the cluster reports. */
+    sendTransaction: (transaction: Uint8Array | string) => Promise<string>;
+    /** Poll a signature. `"unknown"` is its own answer, not a failure. */
+    getStatus: (signature: string) => Promise<{
+        status: SolanaConfirmationStatus;
+        error: string | null;
+    }>;
+    isSigning: boolean;
+    isSending: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+/**
+ * Sign and send Solana transactions through whichever wallet is connected.
+ *
+ * The wallet is not asked to understand the transaction. It fills its own
+ * signature slot and, for send, hands the bytes to a cluster.
+ */
+declare function useSolanaTransaction(): UseSolanaTransactionReturn;
+
+/**
+ * useSwitchChain Hook
+ *
+ * Provides the switchChain method with loading/error state tracking.
+ *
+ * @see SRS-009 §7.2
+ */
+interface UseSwitchChainReturn {
+    /** Switch the active chain for the current session */
+    switchChain: (chainId: string) => Promise<void>;
+    /** Whether a chain switch is in progress */
+    isSwitching: boolean;
+    /** The currently active chain ID */
+    currentChainId: string | null;
+    /** The last error that occurred during chain switch (if any) */
+    error: Error | null;
+    /** Clear the error state */
+    clearError: () => void;
+}
+declare function useSwitchChain(): UseSwitchChainReturn;
+
+interface TokenInfo {
+    /** ERC-20 token contract address */
+    address: Address;
+    /** Token symbol (e.g. "USDC", "LINK") */
+    symbol: string;
+    /** Token decimals (e.g. 6 for USDC, 18 for most) */
+    decimals: number;
+    /** Optional display name */
+    name?: string;
+}
+interface UseTokenBalanceOptions {
+    /** ERC-20 token(s) to query */
+    tokens: TokenInfo[];
+    /** Auto-refresh interval in milliseconds. Default: undefined (no auto-refresh). */
+    refreshInterval?: number;
+}
+interface TokenBalanceResult {
+    address: Address;
+    symbol: string;
+    decimals: number;
+    name?: string;
+    /** Raw balance as string (in smallest unit), or null if not loaded */
+    balance: string | null;
+    /** Human-readable formatted balance, or null if not loaded */
+    formatted: string | null;
+}
+declare function useTokenBalance(options: UseTokenBalanceOptions): {
+    /** Array of token balance results */
+    tokenBalances: TokenBalanceResult[];
+    isLoading: boolean;
+    error: Error | null;
+    /** Re-fetch all token balances */
+    refetch: () => Promise<void>;
+    /** Get a specific token balance by contract address */
+    getTokenBalance: (tokenAddress: Address) => TokenBalanceResult | undefined;
+    chain: _naculus_connect_appkit_core.WalletChain | null;
+};
+
+interface UseTxHistoryResult {
+    entries: TxStatusEntry[];
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    summary: {
+        pending: number;
+        confirmed: number;
+        failed: number;
+    };
+}
+/**
+ * Query transaction history.
+ * address defaults to current wallet address; chainId defaults to current chain.
+ */
+declare function useTxHistory(address?: string, chainId?: number, monitor?: TxMonitorLike): UseTxHistoryResult;
+
+/**
+ * useUserOpStatus
+ *
+ * React hook for tracking ERC-4337 UserOperation lifecycle.
+ * Polls the bundler for UserOperation receipt and reports status transitions.
+ *
+ * @example
+ * ```tsx
+ * const { userOpHash, status, receipt, error } = useUserOpStatus({
+ *   userOpHash: "0x...",
+ *   bundlerUrl: "https://api.pimlico.io/v2/1/rpc?apikey=...",
+ *   pollInterval: 2000,
+ * });
+ *
+ * if (status === "confirmed") {
+ *   console.log("UserOp included in block!");
+ * }
+ * ```
+ */
+
+type UserOpStatus = "idle" | "pending" | "confirmed" | "failed" | "not_found";
+interface UseUserOpStatusOptions {
+    /** The UserOperation hash to track */
+    userOpHash?: Hex | null;
+    /** Bundler RPC URL */
+    bundlerUrl?: string;
+    /** Polling interval in milliseconds (default: 2000) */
+    pollInterval?: number;
+    /** Maximum number of retries (default: 30) */
+    maxRetries?: number;
+    /** Auto-start polling when userOpHash is provided */
+    autoStart?: boolean;
+}
+interface UseUserOpStatusReturn {
+    /** Current status of the UserOperation */
+    status: UserOpStatus;
+    /** UserOperation receipt (available when confirmed or failed) */
+    receipt: UserOperationReceipt | null;
+    /** The userOpHash being tracked */
+    userOpHash: Hex | null;
+    /** Error state */
+    error: Error | null;
+    /** Whether polling is active */
+    isPolling: boolean;
+    /** Time elapsed since tracking started (ms) */
+    elapsedMs: number;
+    /** Number of poll attempts made */
+    attempts: number;
+    /** Start tracking a UserOperation */
+    start: (hash: Hex) => void;
+    /** Stop tracking */
+    stop: () => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for tracking the lifecycle of an ERC-4337 UserOperation.
+ *
+ * @param options - Configuration for polling behavior
+ * @returns UserOperation status, receipt, and lifecycle controls
+ */
+declare function useUserOpStatus(options?: UseUserOpStatusOptions): UseUserOpStatusReturn;
+
+/**
+ * useValidateDestination — address blackhole prevention hook.
+ *
+ * Validates that a destination address is not a known burn/zero address
+ * before sending a transaction. Returns { isValid, warning, level }.
+ *
+ * Level: "ok" | "warning" | "blocked"
+ */
+/**
+ * What the four syntactic checks below found.
+ *
+ * `"ok"` was `"safe"`, which this function is in no position to say. It checks
+ * that an address is non-empty, well-formed, and not the zero or a burn
+ * address — nothing about whether the recipient is who the user thinks. It
+ * cannot see an address-poisoning lookalike, a contract that will not release
+ * the funds, or a known-malicious destination. Labelling that "safe" put a
+ * green tick beside a scammer's address.
+ */
+type AddressValidationLevel = "ok" | "warning" | "blocked";
+interface AddressValidationResult {
+    isValid: boolean;
+    level: AddressValidationLevel;
+    warning: string | null;
+}
+declare function validateDestination(address: string): AddressValidationResult;
+interface UseValidateDestinationOptions {
+    address: string;
+}
+interface UseValidateDestinationReturn {
+    validation: AddressValidationResult;
+}
+declare function useValidateDestination({ address }: UseValidateDestinationOptions): UseValidateDestinationReturn;
+
+declare function useViemClient(): {
+    publicClient: PublicClient | null;
+    walletClient: WalletClient | null;
+    chains: WalletChain[];
+};
+
+declare function useWallet(): {
+    status: _naculus_connect_appkit_core.ConnectionStatus;
+    session: _naculus_connect_core.UniversalWalletSession | null;
+    accounts: string[];
+    chainId: string | null;
+    error: Error | null;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isReconnecting: boolean;
+    isDisconnected: boolean;
+    currentAccount: string;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    reconnect: () => Promise<void>;
+    switchChain: (chainId: string) => Promise<void>;
+};
+
+interface UserFriendlyError {
+    title: string;
+    description: string;
+    code?: string;
+}
+interface UseWeb3ErrorHandlerReturn {
+    /** Current error from the provider */
+    error: Error | null;
+    /** User-friendly representation of the current error */
+    friendlyError: UserFriendlyError | null;
+    /** Clear the current error */
+    clearError: () => void;
+    /** Check if current error is retryable */
+    isRetryable: boolean;
+    /** Get a user-friendly version of any error */
+    formatError: (error: unknown) => UserFriendlyError;
+    /** Wraps an async function with error formatting */
+    wrapAsync: <T>(fn: () => Promise<T>) => () => Promise<T>;
+}
+/**
+ * Hook that provides user-friendly error handling for web3 operations.
+ *
+ * Features:
+ * - Maps WalletError codes to human-readable messages
+ * - Provides retry detection for transient errors
+ * - Wraps async operations with consistent error formatting
+ * - Exposes the current error state from Web3ConnectProvider
+ *
+ * @example
+ * ```tsx
+ * const { friendlyError, clearError, isRetryable, wrapAsync } = useWeb3ErrorHandler();
+ *
+ * // Show error in UI
+ * if (friendlyError) {
+ *   return <ErrorDisplay title={friendlyError.title} message={friendlyError.description} />;
+ * }
+ *
+ * // Wrap an operation
+ * const safeConnect = wrapAsync(() => connect());
+ * await safeConnect();
+ * ```
+ */
+declare function useWeb3ErrorHandler(): UseWeb3ErrorHandlerReturn;
+
+interface Web3ContextValue extends Web3State, Web3Actions {
+    isConnected: boolean;
+    chains: WalletChain[];
+    /** Client owned by this provider instance. */
+    client: Web3Client;
+    /** SessionManager instance for multi-chain session management */
+    sessionManager: SessionManager | null;
+}
+declare const Web3Context: React__default.Context<Web3ContextValue | null>;
+interface Web3ConnectProviderProps {
+    children: React__default.ReactNode;
+    config: Web3ConnectConfig;
+    autoConnect?: boolean;
+}
+declare function Web3ConnectProvider({ children, config, autoConnect, }: Web3ConnectProviderProps): React__default.JSX.Element;
+declare function useWeb3(): Web3ContextValue;
+
+/**
+ * useTokenList — React hook for loading token lists.
+ *
+ * Manages TokenListManager lifecycle and provides reactive
+ * token data scoped to a specific chain.
+ */
+
+interface UseTokenListOptions {
+    /** Auto-load on mount (default: true) */
+    autoLoad?: boolean;
+    /** Custom sources (overrides defaults) */
+    sources?: TokenListSource[];
+}
+interface UseTokenListReturn {
+    /** Loaded tokens for the specified chain */
+    tokens: TokenListEntry[];
+    /** Whether the initial load is in progress */
+    isLoading: boolean;
+    /** Whether tokens have been loaded at least once */
+    isLoaded: boolean;
+    /** Last error, if any */
+    error: Error | null;
+    /** Force a full refresh from all sources */
+    refetch: () => Promise<void>;
+}
+/**
+ * React hook for accessing token lists for a specific chain.
+ *
+ * @example
+ * const { tokens, isLoading } = useTokenList("eip155:1");
+ * // tokens → [WETH, USDC, USDT, DAI, ...]
+ */
+declare function useTokenList(chainId?: string, options?: UseTokenListOptions): UseTokenListReturn;
+
+/**
+ * useTokenSearch — React hook for searching tokens.
+ *
+ * Debounced search over loaded token lists.
+ * Returns structured results (exact + fuzzy matches).
+ */
+
+interface UseTokenSearchReturn {
+    /** Structured search results */
+    results: TokenSearchResult;
+    /** Whether a search is currently running */
+    isSearching: boolean;
+}
+/**
+ * React hook for searching tokens by symbol, name, or address.
+ *
+ * Debounced 300ms to avoid excessive re-renders during typing.
+ *
+ * @example
+ * const { results, isSearching } = useTokenSearch("USDC");
+ * // results.exact → [USDC on ETH]
+ * // results.fuzzy → [USDC.e on AVAX]
+ */
+declare function useTokenSearch(query: string, chainId?: string): UseTokenSearchReturn;
+
+/**
+ * TokenSelector — chain-aware, searchable token selection component.
+ *
+ * Features:
+ * - Loads token list for the given chain
+ * - Search by symbol, name, or address
+ * - Displays token logo, symbol, name, and decimals
+ * - Calls onSelect when a token is chosen
+ */
+
+interface TokenSelectorProps {
+    /** Chain ID in CAIP-2 format (e.g. "eip155:1") */
+    chainId: string;
+    /** Called when a token is selected */
+    onSelect: (token: TokenListEntry) => void;
+    /** Called to close/dismiss the selector */
+    onClose: () => void;
+    /** Optional configuration */
+    options?: {
+        /** Show popular/recommended tokens (default: true) */
+        showRecommendations?: boolean;
+        /** Custom filter for tokens */
+        filter?: (token: TokenListEntry) => boolean;
+    };
+}
+/**
+ * TokenSelector — a dropdown/modal component for selecting tokens.
+ *
+ * @example
+ * <TokenSelector
+ *   chainId="eip155:1"
+ *   onSelect={(token) => setSelectedToken(token)}
+ *   onClose={() => setOpen(false)}
+ * />
+ */
+declare function TokenSelector({ chainId, onSelect, onClose, options, }: TokenSelectorProps): React__default.JSX.Element;
+
+declare const DEFAULT_EVM_CHAINS: WalletChain[];
+/**
+ * The configured chain for a CAIP-2 id.
+ *
+ * Delegates rather than parsing again. The version this replaces did
+ * `parseInt(chainId.split(":")[1])`, which answers 5 for
+ * `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`.
+ */
+declare function getChainById(chains: WalletChain[], chainId: string): WalletChain | undefined;
+declare function getDefaultChains(): WalletChain[];
+
+/**
+ * User-friendly error messages for WalletError codes and common errors.
+ * Maps internal error codes to human-readable messages that can be shown in toasts/UI.
+ */
+/**
+ * User-friendly title for each WalletError code.
+ */
+declare const WALLET_ERROR_TITLES: Record<string, string>;
+/**
+ * User-friendly description for each WalletError code.
+ */
+declare const WALLET_ERROR_DESCRIPTIONS: Record<string, string>;
+/**
+ * Get a user-friendly error message object from any error.
+ */
+declare function getUserFriendlyError(error: unknown): {
+    title: string;
+    description: string;
+    code?: string;
+};
+/**
+ * Check if an error is retryable (transient).
+ */
+declare function isRetryableError(error: unknown): boolean;
+
+/**
+ * i18n — ponytail approach: static key-value map, no framework dependency.
+ *
+ * All UI strings go through here. No hardcoded text in components.
+ * To add a language: copy this file and translate the values.
+ */
+type Locale = "en" | "zh";
+declare const en: {
+    readonly "storage.critical.title": "Insecure Storage Detected";
+    readonly "storage.critical.body": "Your browser does not support IndexedDB. Wallet data is stored in plaintext in localStorage and could be exposed to XSS attacks. We strongly recommend switching to a modern browser.";
+    readonly "storage.warning.title": "Storage Security Warning";
+    readonly "storage.warning.body": "Your browser does not support IndexedDB, but your wallet data is encrypted with AES-256-GCM. Consider switching browsers for better origin isolation.";
+    readonly "address.empty": "Address is empty";
+    readonly "address.invalid_format": "Invalid address format (expected 0x + 40 hex chars)";
+    readonly "address.zero_address": "Address is the zero address — funds would be permanently lost";
+    readonly "address.burn_address": "Address appears to be a burn address — funds would be permanently lost";
+    readonly "wallet.connect": "Connect Wallet";
+    readonly "wallet.disconnect": "Disconnect";
+    readonly "wallet.connecting": "Connecting...";
+    readonly "wallet.copy_address": "Copy address";
+    readonly "wallet.copied": "Copied!";
+    readonly "wallet.view_on_explorer": "View on Explorer";
+    readonly "wallet.retry": "Retry";
+    readonly "wallet.connection_failed": "Connection failed";
+    readonly "wallet.scan_qr": "Scan with your wallet app";
+    readonly "embedded.generate": "Create Wallet";
+    readonly "embedded.import": "Import Wallet";
+    readonly "embedded.backup_seed": "Back up your seed phrase";
+    readonly "embedded.backup_warning": "Anyone with your seed phrase can access your funds. Store it securely.";
+    readonly "embedded.backup_done": "I've saved my seed phrase";
+    readonly "embedded.wipe": "Remove Wallet";
+    readonly "embedded.wipe_confirm": "Are you sure? This cannot be undone.";
+};
+declare function setLocale(locale: Locale): void;
+declare function getLocale(): Locale;
+declare function t(key: keyof typeof en): string;
+
+/**
+ * This file was automatically generated by the Stencil React Output Target.
+ * Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+
+type AppkitAccordionEvents = {
+    onAppkitToggle: EventName<AppkitAccordionCustomEvent<boolean>>;
+};
+declare const AppkitAccordion: StencilReactComponent<AppkitAccordion$1, AppkitAccordionEvents, Components.AppkitAccordion>;
+type AppkitAccountButtonEvents = NonNullable<unknown>;
+declare const AppkitAccountButton: StencilReactComponent<AppkitAccountButton$1, AppkitAccountButtonEvents, Components.AppkitAccountButton>;
+type AppkitAlertDialogEvents = {
+    onAppkitClose: EventName<AppkitAlertDialogCustomEvent<void>>;
+    onAppkitOpenChange: EventName<AppkitAlertDialogCustomEvent<boolean>>;
+};
+declare const AppkitAlertDialog: StencilReactComponent<AppkitAlertDialog$1, AppkitAlertDialogEvents, Components.AppkitAlertDialog>;
+type AppkitAvatarEvents = NonNullable<unknown>;
+declare const AppkitAvatar: StencilReactComponent<AppkitAvatar$1, AppkitAvatarEvents, Components.AppkitAvatar>;
+type AppkitBadgeEvents = NonNullable<unknown>;
+declare const AppkitBadge: StencilReactComponent<AppkitBadge$1, AppkitBadgeEvents, Components.AppkitBadge>;
+type AppkitButtonEvents = NonNullable<unknown>;
+declare const AppkitButton: StencilReactComponent<AppkitButton$1, AppkitButtonEvents, Components.AppkitButton>;
+type AppkitCardEvents = NonNullable<unknown>;
+declare const AppkitCard: StencilReactComponent<AppkitCard$1, AppkitCardEvents, Components.AppkitCard>;
+type AppkitCardContentEvents = NonNullable<unknown>;
+declare const AppkitCardContent: StencilReactComponent<AppkitCardContent$1, AppkitCardContentEvents, Components.AppkitCardContent>;
+type AppkitCardDescriptionEvents = NonNullable<unknown>;
+declare const AppkitCardDescription: StencilReactComponent<AppkitCardDescription$1, AppkitCardDescriptionEvents, Components.AppkitCardDescription>;
+type AppkitCardFooterEvents = NonNullable<unknown>;
+declare const AppkitCardFooter: StencilReactComponent<AppkitCardFooter$1, AppkitCardFooterEvents, Components.AppkitCardFooter>;
+type AppkitCardHeaderEvents = NonNullable<unknown>;
+declare const AppkitCardHeader: StencilReactComponent<AppkitCardHeader$1, AppkitCardHeaderEvents, Components.AppkitCardHeader>;
+type AppkitCardTitleEvents = NonNullable<unknown>;
+declare const AppkitCardTitle: StencilReactComponent<AppkitCardTitle$1, AppkitCardTitleEvents, Components.AppkitCardTitle>;
+type AppkitCheckboxEvents = {
+    onAppkitChange: EventName<AppkitCheckboxCustomEvent<boolean>>;
+};
+declare const AppkitCheckbox: StencilReactComponent<AppkitCheckbox$1, AppkitCheckboxEvents, Components.AppkitCheckbox>;
+type AppkitCollapsibleEvents = {
+    onAppkitToggle: EventName<AppkitCollapsibleCustomEvent<boolean>>;
+};
+declare const AppkitCollapsible: StencilReactComponent<AppkitCollapsible$1, AppkitCollapsibleEvents, Components.AppkitCollapsible>;
+type AppkitConnectButtonEvents = {
+    onAppkitConnect: EventName<AppkitConnectButtonCustomEvent<{
+        kind: string;
+        walletId?: string;
+    }>>;
+    onAppkitDisconnect: EventName<AppkitConnectButtonCustomEvent<void>>;
+    onAppkitStartPairing: EventName<AppkitConnectButtonCustomEvent<void>>;
+    onAppkitRetry: EventName<AppkitConnectButtonCustomEvent<void>>;
+    onAppkitCancelPairing: EventName<AppkitConnectButtonCustomEvent<void>>;
+    onAppkitMobileDeepLink: EventName<AppkitConnectButtonCustomEvent<void>>;
+    onAppkitCopyAddress: EventName<AppkitConnectButtonCustomEvent<string>>;
+};
+declare const AppkitConnectButton: StencilReactComponent<AppkitConnectButton$1, AppkitConnectButtonEvents, Components.AppkitConnectButton>;
+type AppkitDialogEvents = {
+    onAppkitClose: EventName<AppkitDialogCustomEvent<void>>;
+    onAppkitOpenChange: EventName<AppkitDialogCustomEvent<boolean>>;
+};
+declare const AppkitDialog: StencilReactComponent<AppkitDialog$1, AppkitDialogEvents, Components.AppkitDialog>;
+type AppkitDropdownMenuEvents = {
+    onAppkitSelect: EventName<AppkitDropdownMenuCustomEvent<string>>;
+};
+declare const AppkitDropdownMenu: StencilReactComponent<AppkitDropdownMenu$1, AppkitDropdownMenuEvents, Components.AppkitDropdownMenu>;
+type AppkitInputEvents = {
+    onAppkitChange: EventName<AppkitInputCustomEvent<string>>;
+};
+declare const AppkitInput: StencilReactComponent<AppkitInput$1, AppkitInputEvents, Components.AppkitInput>;
+type AppkitPopoverEvents = {
+    onAppkitOpenChange: EventName<AppkitPopoverCustomEvent<boolean>>;
+};
+declare const AppkitPopover: StencilReactComponent<AppkitPopover$1, AppkitPopoverEvents, Components.AppkitPopover>;
+type AppkitProgressEvents = NonNullable<unknown>;
+declare const AppkitProgress: StencilReactComponent<AppkitProgress$1, AppkitProgressEvents, Components.AppkitProgress>;
+type AppkitScrollAreaEvents = NonNullable<unknown>;
+declare const AppkitScrollArea: StencilReactComponent<AppkitScrollArea$1, AppkitScrollAreaEvents, Components.AppkitScrollArea>;
+type AppkitSelectEvents = {
+    onAppkitChange: EventName<AppkitSelectCustomEvent<string>>;
+};
+declare const AppkitSelect: StencilReactComponent<AppkitSelect$1, AppkitSelectEvents, Components.AppkitSelect>;
+type AppkitSeparatorEvents = NonNullable<unknown>;
+declare const AppkitSeparator: StencilReactComponent<AppkitSeparator$1, AppkitSeparatorEvents, Components.AppkitSeparator>;
+type AppkitSkeletonEvents = NonNullable<unknown>;
+declare const AppkitSkeleton: StencilReactComponent<AppkitSkeleton$1, AppkitSkeletonEvents, Components.AppkitSkeleton>;
+type AppkitSwitchEvents = {
+    onAppkitChange: EventName<AppkitSwitchCustomEvent<boolean>>;
+};
+declare const AppkitSwitch: StencilReactComponent<AppkitSwitch$1, AppkitSwitchEvents, Components.AppkitSwitch>;
+type AppkitTabsEvents = {
+    onAppkitTabChange: EventName<AppkitTabsCustomEvent<string>>;
+};
+declare const AppkitTabs: StencilReactComponent<AppkitTabs$1, AppkitTabsEvents, Components.AppkitTabs>;
+type AppkitToggleGroupEvents = {
+    onAppkitChange: EventName<AppkitToggleGroupCustomEvent<string[]>>;
+};
+declare const AppkitToggleGroup: StencilReactComponent<AppkitToggleGroup$1, AppkitToggleGroupEvents, Components.AppkitToggleGroup>;
+type AppkitTooltipEvents = NonNullable<unknown>;
+declare const AppkitTooltip: StencilReactComponent<AppkitTooltip$1, AppkitTooltipEvents, Components.AppkitTooltip>;
+
+export { type AddressValidationLevel, type AddressValidationResult, AppkitAccordion, type AppkitAccordionEvents, AppkitAccountButton, type AppkitAccountButtonEvents, AppkitAlertDialog, type AppkitAlertDialogEvents, AppkitAvatar, type AppkitAvatarEvents, AppkitBadge, type AppkitBadgeEvents, AppkitButton, type AppkitButtonEvents, AppkitCard, AppkitCardContent, type AppkitCardContentEvents, AppkitCardDescription, type AppkitCardDescriptionEvents, type AppkitCardEvents, AppkitCardFooter, type AppkitCardFooterEvents, AppkitCardHeader, type AppkitCardHeaderEvents, AppkitCardTitle, type AppkitCardTitleEvents, AppkitCheckbox, type AppkitCheckboxEvents, AppkitCollapsible, type AppkitCollapsibleEvents, AppkitConnectButton, type AppkitConnectButtonEvents, AppkitDialog, type AppkitDialogEvents, AppkitDropdownMenu, type AppkitDropdownMenuEvents, AppkitInput, type AppkitInputEvents, AppkitPopover, type AppkitPopoverEvents, AppkitProgress, type AppkitProgressEvents, AppkitScrollArea, type AppkitScrollAreaEvents, AppkitSelect, type AppkitSelectEvents, AppkitSeparator, type AppkitSeparatorEvents, AppkitSkeleton, type AppkitSkeletonEvents, AppkitSwitch, type AppkitSwitchEvents, AppkitTabs, type AppkitTabsEvents, AppkitToggleGroup, type AppkitToggleGroupEvents, AppkitTooltip, type AppkitTooltipEvents, type AtomicSupport, type ChainCapabilities, type CostComparison, type CostComparisonOperation, type CostComparisonOptions, DEFAULT_EVM_CHAINS, type DelegationPolicyPreview, type EmbeddedWalletAccountView, type EmbeddedWalletView, type EvmTransaction, type ExecuteError, type ExecuteOptions, type ExecuteRouteResult, type ExecutionPreview, type ExecutionRoute, type Locale, type PolicyExecutionAdapter, type PolicyExecutionCheck, type PolicyExecutionRoute, type PolicyExecutionSubmission, type PreparedPolicyExecution, type Quote, type QuoteOptions, type SIWxConfig, type SendCallsStatus, type TokenBalanceResult, type TokenInfo, TokenSelector, type TokenSelectorProps, TxMonitorContext, type TxMonitorLike, type TxStatus, type TxStatusEntry, type UseCapabilitiesReturn, type UseCompareCostsInput, type UseCompareCostsReturn, type UseCreateSessionKeyReturn, type UseDelegationPolicyOptions, type UseDelegationPolicyReturn, type UseDelegationReturn, type UseERC20AllowanceOptions, type UseERC20AllowanceReturn, type UseERC20ApproveOptions, type UseERC20ApproveReturn, type UseERC20TransferOptions, type UseERC20TransferReturn, type UseERC20TransferSimulationOptions, type UseERC20TransferSimulationReturn, type UseEmbeddedWalletReturn, type UseExecuteCallsOptions, type UseExecuteCallsReturn, type UseExecuteRouteReturn, type UseLastTxResult, type UseLookupAddressOptions, type UseLookupAddressResult, type UsePassphraseGateReturn, type UseResolveNameOptions, type UseResolveNameResult, type UseRevokeSessionReturn, type UseRouteQuoteInput, type UseRouteQuoteReturn, type UseSIWxLoginOptions, type UseSIWxLoginReturn, type UseSIWxSessionOptions, type UseSIWxSessionReturn, type UseSendUserOperationOptions, type UseSendUserOperationReturn, type UseSendWithSessionReturn, type UseSessionKeysReturn, type UseSessionReturn, type UseSignInWithEthereumOptions, type UseSignInWithEthereumReturn, type UseSignInWithXOptions, type UseSignInWithXReturn, type UseSimulateTransferOptions, type UseSimulateTransferReturn, type UseSiwxAuthSessionOptions, type UseSiwxAuthSessionReturn, type UseSmartAccountOptions, type UseSmartAccountReturn, type UseSolanaAccountReturn, type UseSolanaBalanceOptions, type UseSolanaBalanceReturn, type UseSolanaTransactionReturn, type UseSwitchChainReturn, type UseTokenBalanceOptions, type UseTokenListOptions, type UseTokenListReturn, type UseTokenSearchReturn, type UseTransactionSimulationReturn, type UseTxHistoryResult, type UseTxMonitorResult, type UseUserOpStatusOptions, type UseUserOpStatusReturn, type UseValidateDestinationOptions, type UseValidateDestinationReturn, type UseWalletReturn, type UseWeb3ErrorHandlerReturn, type UserFriendlyError, type UserOpStatus, WALLET_ERROR_DESCRIPTIONS, WALLET_ERROR_TITLES, type Web3Actions, Web3Client, type Web3ConnectConfig, Web3ConnectProvider, type Web3ConnectProviderProps, Web3Context, buildDelegationPolicyMessage, getChainById, getDefaultChains, getLocale, getUserFriendlyError, isRetryableError, resetSessionKeyManager, setLocale, t, useAccount, useBalance, useCapabilities, useChain, useCompareCosts, useConnect, useCreateSessionKey, useDelegation, useDelegationPolicy, useDisconnect, useERC20Allowance, useERC20Approve, useERC20Transfer, useERC20TransferSimulation, useEmbeddedWallet, useExecuteCalls, useExecuteRoute, useLastTx, useLookupAddress, useNotification, usePassphraseGate, useResolveName, useRevokeSession, useRouteQuote, useSIWxLogin, useSIWxSession, useSendCalls, useSendTransaction, useSendUserOperation, useSendWithSession, useSession, useSessionKeys, useSignInWithEthereum, useSignInWithX, useSignMessage, useSimulateTransfer, useSiwxAuthSession, useSmartAccount, useSolanaAccount, useSolanaBalance, useSolanaTransaction, useSwitchChain, useTokenBalance, useTokenList, useTokenSearch, useTransactionSimulation, useTxHistory, useTxMonitor, useUserOpStatus, useValidateDestination, useViemClient, useWallet, useWeb3, useWeb3ErrorHandler, validateDestination };