@solana/react-hooks 0.3.0 → 0.5.1

package/README.md

@@ -13,15 +13,18 @@ pnpm add @solana/react-hooks
 
 ## Minimal example
 
-Mount the provider once and call hooks anywhere in the subtree.
+Build connectors first, create a client, and hand it to the combined provider.
 
 ```tsx
-import {
-    SolanaClientProvider,
-    useBalance,
-    useConnectWallet,
-    useWallet,
-} from '@solana/react-hooks';
+import { autoDiscover, backpack, createClient, phantom, solflare } from '@solana/client';
+import { SolanaProvider, useBalance, useConnectWallet, useWallet } from '@solana/react-hooks';
+
+const walletConnectors = [...phantom(), ...solflare(), ...backpack(), ...autoDiscover()];
+const client = createClient({
+    endpoint: 'https://api.devnet.solana.com',
+    websocketEndpoint: 'wss://api.devnet.solana.com',
+    walletConnectors,
+});
 
 function WalletButton() {
     const connectWallet = useConnectWallet();
@@ -40,19 +43,23 @@ function WalletBalance() {
 
 export function App() {
     return (
-        <SolanaClientProvider
-            config={{
-                endpoint: 'https://api.devnet.solana.com',
-                websocketEndpoint: 'wss://api.devnet.solana.com',
-            }}
-        >
+        <SolanaProvider client={client} query={{ suspense: true }}>
             <WalletButton />
             <WalletBalance />
-        </SolanaClientProvider>
+        </SolanaProvider>
     );
 }
 ```
 
+`SolanaProvider` composes `SolanaClientProvider` and `SolanaQueryProvider` with SWR v2-aligned defaults
+(`revalidateOnFocus`/`revalidateOnReconnect`/`revalidateIfStale` are `true`, `dedupingInterval` is `2000`,
+`focusThrottleInterval` is `5000`). Override them via the `query.config` prop or per-hook `swr` options.
+Prefer passing a `client`; `config`-based setup on `SolanaClientProvider` is still available for bespoke
+composition.
+
+Every hook exposes `UseHookNameParameters` / `UseHookNameReturnType` aliases so wrapper components stay in
+sync with the public API.
+
 ## Hooks at a glance
 
 - `useWallet`, `useConnectWallet`, `useDisconnectWallet` – read or update the current wallet session.
@@ -285,6 +292,10 @@ Wrap a subtree with `<SolanaQueryProvider>` and call hooks like `useLatestBlockh
 Suspense later? Pass `suspense` to `SolanaQueryProvider` and wrap just the section that should pause in a
 local `<Suspense>` boundary—no hook changes required:
 
+The query provider ships SWR v2-aligned defaults: `revalidateOnFocus`/`revalidateOnReconnect`/`revalidateIfStale`
+are `true`, `dedupingInterval` is `2000`, and `focusThrottleInterval` is `5000`. Override them per-provider via the
+`query.config` prop or per-hook via the `swr` option.
+
 ```tsx
 import { SolanaQueryProvider, useBalance } from '@solana/react-hooks';
 import { Suspense } from 'react';
@@ -314,7 +325,7 @@ Poll or refetch the cluster's latest blockhash.
 import { SolanaQueryProvider, useLatestBlockhash } from '@solana/react-hooks';
 
 function BlockhashTicker() {
-    const latest = useLatestBlockhash({ refreshInterval: 20_000 });
+    const latest = useLatestBlockhash({ swr: { refreshInterval: 20_000 } });
     if (latest.status === 'loading') return <p>Fetching blockhash…</p>;
     if (latest.status === 'error') return <p role="alert">Failed to fetch blockhash.</p>;
 
@@ -339,7 +350,15 @@ export function BlockhashCard() {
 ### Program accounts
 
 ```tsx
-import { SolanaClientProvider, SolanaQueryProvider, useProgramAccounts } from '@solana/react-hooks';
+import { autoDiscover, backpack, createClient, phantom, solflare } from '@solana/client';
+import { SolanaProvider, SolanaQueryProvider, useProgramAccounts } from '@solana/react-hooks';
+
+const walletConnectors = [...phantom(), ...solflare(), ...backpack(), ...autoDiscover()];
+const client = createClient({
+    endpoint: 'https://api.devnet.solana.com',
+    websocketEndpoint: 'wss://api.devnet.solana.com',
+    walletConnectors,
+});
 
 function ProgramAccountsList({ programAddress }) {
     const query = useProgramAccounts(programAddress);
@@ -361,11 +380,11 @@ function ProgramAccountsList({ programAddress }) {
 
 export function QueryDemo({ programAddress }) {
     return (
-        <SolanaClientProvider config={{ endpoint: 'https://api.devnet.solana.com' }}>
+        <SolanaProvider client={client}>
             <SolanaQueryProvider>
                 <ProgramAccountsList programAddress={programAddress} />
             </SolanaQueryProvider>
-        </SolanaClientProvider>
+        </SolanaProvider>
     );
 }
 ```
@@ -394,12 +413,15 @@ function SimulationLogs({ transaction }) {
 ## Going further
 
 - Wallet connection UI: `useWalletConnection` gives you the current wallet, connect/disconnect
-  helpers, and the connector list (from `client.connectors` when provided, with optional Wallet
-  Standard discovery fallback). Pair it with your preferred UI, or `WalletConnectionManager` for a
-  simple modal state helper.
+  helpers, and the connector list from `client.connectors` (or an explicit override). Pair it with
+  your preferred UI, or `WalletConnectionManager` for a simple modal state helper.
 - Signing helpers: the wallet session returned by `useWallet` exposes `signMessage`,
   `signTransaction`, and `sendTransaction` when supported by the connector. These connector methods
   replace the deprecated Wallet Standard shims.
+- Query hooks keep SWR options under `swr` for consistency (for example,
+  `useProgramAccounts(address, { swr: { revalidateOnFocus: false } })`) and expose typed parameter
+  and return aliases across all hooks.
+- Type helpers: use `UseHookNameParameters` / `UseHookNameReturnType` for public hooks.
 - Looking for examples? See `examples/react-hooks` for a ready-to-run, tabbed playground that wires
   the provider, hooks, and mock UIs together across wallet/state, transaction, and query demos.
 

package/dist/index.browser.cjs

@@ -62,11 +62,11 @@ var QUERY_NAMESPACE = "@solana/react-hooks";
 function useSolanaRpcQuery(scope, args, fetcher, options = {}) {
   const client = useSolanaClient();
   const cluster = useClientStore((state) => state.cluster);
-  const { disabled = false, ...restOptions } = options;
+  const { disabled = false, swr } = options;
   const providerSuspensePreference = useQuerySuspensePreference();
   const suspenseEnabled = !disabled && Boolean(providerSuspensePreference);
   const swrOptions = {
-    ...restOptions,
+    ...swr ?? {},
     suspense: suspenseEnabled
   };
   const key = react.useMemo(() => {
@@ -75,59 +75,105 @@ function useSolanaRpcQuery(scope, args, fetcher, options = {}) {
     }
     return [QUERY_NAMESPACE, scope, cluster.endpoint, cluster.commitment, ...args];
   }, [cluster.commitment, cluster.endpoint, args, scope, disabled]);
-  const swr = useSWR__default.default(key, () => fetcher(client), swrOptions);
+  const swrResponse = useSWR__default.default(key, () => fetcher(client), swrOptions);
   const [dataUpdatedAt, setDataUpdatedAt] = react.useState(
-    () => swr.data !== void 0 ? Date.now() : void 0
+    () => swrResponse.data !== void 0 ? Date.now() : void 0
   );
   react.useEffect(() => {
-    if (swr.data !== void 0) {
+    if (swrResponse.data !== void 0) {
       setDataUpdatedAt(Date.now());
     }
-  }, [swr.data]);
-  const status = swr.error ? "error" : swr.isLoading ? "loading" : swr.data !== void 0 ? "success" : "idle";
-  const refresh = react.useCallback(() => swr.mutate(void 0, { revalidate: true }), [swr.mutate]);
+  }, [swrResponse.data]);
+  const status = swrResponse.error ? "error" : swrResponse.isLoading ? "loading" : swrResponse.data !== void 0 ? "success" : "idle";
+  const refresh = react.useCallback(() => swrResponse.mutate(void 0, { revalidate: true }), [swrResponse.mutate]);
   return {
-    data: swr.data,
+    data: swrResponse.data,
     dataUpdatedAt,
-    error: swr.error ?? null,
+    error: swrResponse.error ?? null,
     isError: status === "error",
-    isLoading: swr.isLoading,
+    isLoading: swrResponse.isLoading,
     isSuccess: status === "success",
-    isValidating: swr.isValidating,
-    mutate: swr.mutate,
+    isValidating: swrResponse.isValidating,
+    mutate: swrResponse.mutate,
     refresh,
     status
   };
 }
 __name(useSolanaRpcQuery, "useSolanaRpcQuery");
+function getLatestBlockhashKey(params = {}) {
+  const { commitment = null, minContextSlot = null } = params;
+  return ["latestBlockhash", commitment, normalizeBigint(minContextSlot)];
+}
+__name(getLatestBlockhashKey, "getLatestBlockhashKey");
+function getProgramAccountsKey(params = {}) {
+  const { programAddress, config } = params;
+  const address = programAddress ? client.toAddress(programAddress) : void 0;
+  const addressKey = address ? client.toAddressString(address) : null;
+  const configKey = client.stableStringify(config ?? null);
+  return ["programAccounts", addressKey, configKey];
+}
+__name(getProgramAccountsKey, "getProgramAccountsKey");
+function getSimulateTransactionKey(params = {}) {
+  const { transaction, config } = params;
+  const wire = transaction ? normalizeWire(transaction) : null;
+  const configKey = client.stableStringify(config ?? null);
+  return ["simulateTransaction", wire, configKey];
+}
+__name(getSimulateTransactionKey, "getSimulateTransactionKey");
+function getSignatureStatusKey(params = {}) {
+  const { config, signature } = params;
+  const signatureKey = signature?.toString() ?? null;
+  const configKey = JSON.stringify(config ?? null);
+  return ["signatureStatus", signatureKey, configKey];
+}
+__name(getSignatureStatusKey, "getSignatureStatusKey");
+function normalizeBigint(value) {
+  if (value === void 0 || value === null) return null;
+  return typeof value === "bigint" ? value : BigInt(Math.floor(value));
+}
+__name(normalizeBigint, "normalizeBigint");
+function normalizeWire(input) {
+  if (!input) return null;
+  if (typeof input === "string") {
+    return input;
+  }
+  return kit.getBase64EncodedWireTransaction(input);
+}
+__name(normalizeWire, "normalizeWire");
+
+// src/queryHooks.ts
 var DEFAULT_BLOCKHASH_REFRESH_INTERVAL = 3e4;
-function useLatestBlockhash(options) {
-  const { commitment, minContextSlot, refreshInterval = DEFAULT_BLOCKHASH_REFRESH_INTERVAL, ...rest } = options ?? {};
-  const normalizedMinContextSlot = react.useMemo(() => {
-    if (minContextSlot === void 0) {
-      return void 0;
-    }
-    return typeof minContextSlot === "bigint" ? minContextSlot : BigInt(Math.floor(minContextSlot));
-  }, [minContextSlot]);
-  const keyArgs = react.useMemo(
-    () => [commitment ?? null, normalizedMinContextSlot ?? null],
-    [commitment, normalizedMinContextSlot]
-  );
+function useLatestBlockhash(options = {}) {
+  const {
+    commitment,
+    minContextSlot,
+    refreshInterval = DEFAULT_BLOCKHASH_REFRESH_INTERVAL,
+    disabled = false,
+    swr
+  } = options;
   const fetcher = react.useCallback(
     async (client) => {
       const fallbackCommitment = commitment ?? client.store.getState().cluster.commitment;
       const plan = client.runtime.rpc.getLatestBlockhash({
         commitment: fallbackCommitment,
-        minContextSlot: normalizedMinContextSlot
+        minContextSlot: normalizeMinContextSlot(minContextSlot)
       });
       return plan.send({ abortSignal: AbortSignal.timeout(15e3) });
     },
-    [commitment, normalizedMinContextSlot]
+    [commitment, minContextSlot]
+  );
+  const query = useSolanaRpcQuery(
+    "latestBlockhash",
+    getLatestBlockhashKey(options),
+    fetcher,
+    {
+      disabled,
+      swr: {
+        refreshInterval,
+        ...swr
+      }
+    }
   );
-  const query = useSolanaRpcQuery("latestBlockhash", keyArgs, fetcher, {
-    refreshInterval,
-    ...rest
-  });
   return {
     ...query,
     blockhash: query.data?.value.blockhash ?? null,
@@ -137,31 +183,33 @@ function useLatestBlockhash(options) {
 }
 __name(useLatestBlockhash, "useLatestBlockhash");
 function useProgramAccounts(programAddress, options) {
-  const { commitment, config, ...queryOptions } = options ?? {};
-  const { disabled: disabledOption, ...restQueryOptions } = queryOptions;
-  const address = react.useMemo(() => programAddress ? client.toAddress(programAddress) : void 0, [programAddress]);
-  const addressKey = react.useMemo(() => address ? client.toAddressString(address) : null, [address]);
-  const configKey = react.useMemo(() => client.stableStringify(config ?? null), [config]);
+  const { commitment, config, swr, disabled: disabledOption } = options ?? {};
   const fetcher = react.useCallback(
-    async (client) => {
+    async (client$1) => {
+      const address = programAddress ? client.toAddress(programAddress) : void 0;
       if (!address) {
         throw new Error("Provide a program address before querying program accounts.");
       }
-      const fallbackCommitment = commitment ?? config?.commitment ?? client.store.getState().cluster.commitment;
+      const fallbackCommitment = commitment ?? config?.commitment ?? client$1.store.getState().cluster.commitment;
       const mergedConfig = {
         ...config ?? {},
         commitment: fallbackCommitment
       };
-      const plan = client.runtime.rpc.getProgramAccounts(address, mergedConfig);
+      const plan = client$1.runtime.rpc.getProgramAccounts(address, mergedConfig);
       return plan.send({ abortSignal: AbortSignal.timeout(2e4) });
     },
-    [address, commitment, config]
+    [commitment, config, programAddress]
+  );
+  const disabled = disabledOption ?? !programAddress;
+  const query = useSolanaRpcQuery(
+    "programAccounts",
+    getProgramAccountsKey({ programAddress, config }),
+    fetcher,
+    {
+      disabled,
+      swr
+    }
   );
-  const disabled = disabledOption ?? !address;
-  const query = useSolanaRpcQuery("programAccounts", [addressKey, configKey], fetcher, {
-    ...restQueryOptions,
-    disabled
-  });
   return {
     ...query,
     accounts: query.data ?? []
@@ -169,8 +217,7 @@ function useProgramAccounts(programAddress, options) {
 }
 __name(useProgramAccounts, "useProgramAccounts");
 function useSimulateTransaction(transaction, options) {
-  const { commitment, config, refreshInterval, ...rest } = options ?? {};
-  const { disabled: disabledOption, revalidateIfStale, revalidateOnFocus, ...queryOptions } = rest;
+  const { commitment, config, refreshInterval, disabled: disabledOption, swr } = options ?? {};
   const wire = react.useMemo(() => {
     if (!transaction) {
       return null;
@@ -180,7 +227,6 @@ function useSimulateTransaction(transaction, options) {
     }
     return kit.getBase64EncodedWireTransaction(transaction);
   }, [transaction]);
-  const configKey = react.useMemo(() => client.stableStringify(config ?? null), [config]);
   const fetcher = react.useCallback(
     async (client) => {
       if (!wire) {
@@ -196,19 +242,31 @@ function useSimulateTransaction(transaction, options) {
     [commitment, config, wire]
   );
   const disabled = disabledOption ?? !wire;
-  const query = useSolanaRpcQuery("simulateTransaction", [wire, configKey], fetcher, {
-    ...queryOptions,
-    refreshInterval,
-    disabled,
-    revalidateIfStale: revalidateIfStale ?? false,
-    revalidateOnFocus: revalidateOnFocus ?? false
-  });
+  const query = useSolanaRpcQuery(
+    "simulateTransaction",
+    getSimulateTransactionKey({ transaction, config }),
+    fetcher,
+    {
+      disabled,
+      swr: {
+        refreshInterval,
+        revalidateIfStale: false,
+        revalidateOnFocus: false,
+        ...swr
+      }
+    }
+  );
   return {
     ...query,
     logs: query.data?.value.logs ?? []
   };
 }
 __name(useSimulateTransaction, "useSimulateTransaction");
+function normalizeMinContextSlot(minContextSlot) {
+  if (minContextSlot === void 0) return void 0;
+  return typeof minContextSlot === "bigint" ? minContextSlot : BigInt(Math.floor(minContextSlot));
+}
+__name(normalizeMinContextSlot, "normalizeMinContextSlot");
 
 // src/hooks.ts
 function createClusterSelector() {
@@ -358,10 +416,19 @@ function useSplToken(mint, options = {}) {
     }
     return helper.fetchBalance(owner, options.commitment);
   }, [helper, owner, options.commitment]);
-  const { data, error, isLoading, isValidating, mutate } = useSWR__default.default(balanceKey, fetchBalance, {
-    revalidateOnFocus: options.revalidateOnFocus ?? false,
-    suspense
-  });
+  const swrOptions = react.useMemo(
+    () => ({
+      revalidateOnFocus: options.revalidateOnFocus ?? false,
+      suspense,
+      ...options.swr ?? {}
+    }),
+    [options.revalidateOnFocus, options.swr, suspense]
+  );
+  const { data, error, isLoading, isValidating, mutate } = useSWR__default.default(
+    balanceKey,
+    fetchBalance,
+    swrOptions
+  );
   const sessionRef = react.useRef(session);
   react.useEffect(() => {
     sessionRef.current = session;
@@ -527,24 +594,6 @@ function useBalance(addressLike, options = {}) {
   );
 }
 __name(useBalance, "useBalance");
-function useWalletStandardConnectors(options) {
-  const overrides = options?.overrides;
-  const disabled = options?.disabled ?? false;
-  const memoisedOptions = react.useMemo(() => overrides ? { overrides } : void 0, [overrides]);
-  const [connectors, setConnectors] = react.useState(
-    () => disabled ? [] : client.getWalletStandardConnectors(memoisedOptions ?? {})
-  );
-  react.useEffect(() => {
-    if (disabled) return;
-    setConnectors(client.getWalletStandardConnectors(memoisedOptions ?? {}));
-    const unwatch = client.watchWalletStandardConnectors(setConnectors, memoisedOptions ?? {});
-    return () => {
-      unwatch();
-    };
-  }, [disabled, memoisedOptions]);
-  return connectors;
-}
-__name(useWalletStandardConnectors, "useWalletStandardConnectors");
 function useTransactionPool(config = {}) {
   const initialInstructions = react.useMemo(
     () => config.instructions ?? [],
@@ -552,7 +601,9 @@ function useTransactionPool(config = {}) {
   );
   const client$1 = useSolanaClient();
   const helper = client$1.helpers.transaction;
-  const blockhashMaxAgeMs = config.latestBlockhash?.refreshInterval ?? 3e4;
+  const swrRefreshInterval = config.latestBlockhash?.swr?.refreshInterval;
+  const blockhashRefreshInterval = config.latestBlockhash?.refreshInterval ?? (typeof swrRefreshInterval === "number" ? swrRefreshInterval : void 0);
+  const blockhashMaxAgeMs = blockhashRefreshInterval ?? 3e4;
   const controller = react.useMemo(
     () => client.createTransactionPoolController({
       blockhashMaxAgeMs,
@@ -678,10 +729,9 @@ function useSendTransaction() {
 }
 __name(useSendTransaction, "useSendTransaction");
 function useSignatureStatus(signatureInput, options = {}) {
-  const { config, ...queryOptions } = options;
+  const { config, disabled: disabledOption, swr } = options;
   const signature = react.useMemo(() => client.normalizeSignature(signatureInput), [signatureInput]);
   const signatureKey = signature?.toString() ?? null;
-  const configKey = react.useMemo(() => JSON.stringify(config ?? null), [config]);
   const fetcher = react.useCallback(
     async (client$1) => {
       if (!signatureKey) {
@@ -696,14 +746,14 @@ function useSignatureStatus(signatureInput, options = {}) {
     },
     [config, signature, signatureKey]
   );
-  const disabled = queryOptions.disabled ?? !signatureKey;
+  const disabled = disabledOption ?? !signatureKey;
   const query = useSolanaRpcQuery(
     "signatureStatus",
-    [signatureKey, configKey],
+    getSignatureStatusKey({ signature: signatureInput, config }),
     fetcher,
     {
-      ...queryOptions,
-      disabled
+      disabled,
+      swr
     }
   );
   const confirmationStatus = client.deriveConfirmationStatus(query.data ?? null);
@@ -722,14 +772,17 @@ function useWaitForSignature(signatureInput, options = {}) {
     watchCommitment,
     ...signatureStatusOptions
   } = options;
-  const { refreshInterval, ...restStatusOptions } = signatureStatusOptions;
+  const { swr, ...restStatusOptions } = signatureStatusOptions;
   const subscribeCommitment = watchCommitment ?? commitment;
   const client$1 = useSolanaClient();
   const normalizedSignature = react.useMemo(() => client.normalizeSignature(signatureInput), [signatureInput]);
   const disabled = disabledOption ?? !normalizedSignature;
   const statusQuery = useSignatureStatus(signatureInput, {
     ...restStatusOptions,
-    refreshInterval: refreshInterval ?? 2e3,
+    swr: {
+      refreshInterval: 2e3,
+      ...swr
+    },
     disabled
   });
   const [subscriptionSettled, setSubscriptionSettled] = react.useState(false);
@@ -785,10 +838,11 @@ function useWaitForSignature(signatureInput, options = {}) {
 __name(useWaitForSignature, "useWaitForSignature");
 var createCache = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Map(), "createCache");
 var DEFAULT_QUERY_CONFIG = Object.freeze({
-  dedupingInterval: 1e3,
-  focusThrottleInterval: 1e3,
+  dedupingInterval: 2e3,
+  focusThrottleInterval: 5e3,
   provider: /* @__PURE__ */ __name(() => createCache(), "provider"),
-  revalidateOnFocus: false,
+  revalidateIfStale: true,
+  revalidateOnFocus: true,
   revalidateOnReconnect: true
 });
 function SolanaQueryProvider({
@@ -976,12 +1030,7 @@ function useWalletConnection(options = {}) {
   const connectWallet = useConnectWallet();
   const disconnectWallet = useDisconnectWallet();
   const client = useSolanaClient();
-  const shouldDiscover = !options.connectors && client.connectors.all.length === 0;
-  const discovered = useWalletStandardConnectors({
-    ...options.discoveryOptions,
-    disabled: !shouldDiscover
-  });
-  const connectors = options.connectors ?? (client.connectors.all.length > 0 ? client.connectors.all : discovered);
+  const connectors = options.connectors ?? client.connectors.all;
   const connect = react.useCallback(
     (connectorId, connectOptions) => connectWallet(connectorId, connectOptions),
     [connectWallet]
@@ -989,6 +1038,7 @@ function useWalletConnection(options = {}) {
   const disconnect = react.useCallback(() => disconnectWallet(), [disconnectWallet]);
   const state = react.useMemo(() => {
     const connectorId = "connectorId" in wallet ? wallet.connectorId : void 0;
+    const currentConnector = connectorId ? connectors.find((connector) => connector.id === connectorId) : void 0;
     const session = wallet.status === "connected" ? wallet.session : void 0;
     const error = wallet.status === "error" ? wallet.error ?? null : null;
     return {
@@ -997,6 +1047,7 @@ function useWalletConnection(options = {}) {
       connecting: wallet.status === "connecting",
       connectors,
       connectorId,
+      currentConnector,
       disconnect,
       error,
       status: wallet.status,
@@ -1006,8 +1057,8 @@ function useWalletConnection(options = {}) {
   return state;
 }
 __name(useWalletConnection, "useWalletConnection");
-function WalletConnectionManager({ children, connectors, discoveryOptions }) {
-  const state = useWalletConnection({ connectors, discoveryOptions });
+function WalletConnectionManager({ children, connectors }) {
+  const state = useWalletConnection({ connectors });
   return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children(state) });
 }
 __name(WalletConnectionManager, "WalletConnectionManager");
@@ -1047,6 +1098,10 @@ exports.SolanaClientProvider = SolanaClientProvider;
 exports.SolanaProvider = SolanaProvider;
 exports.SolanaQueryProvider = SolanaQueryProvider;
 exports.WalletConnectionManager = WalletConnectionManager;
+exports.getLatestBlockhashKey = getLatestBlockhashKey;
+exports.getProgramAccountsKey = getProgramAccountsKey;
+exports.getSignatureStatusKey = getSignatureStatusKey;
+exports.getSimulateTransactionKey = getSimulateTransactionKey;
 exports.useAccount = useAccount;
 exports.useBalance = useBalance;
 exports.useClientStore = useClientStore;
@@ -1069,6 +1124,5 @@ exports.useWalletActions = useWalletActions;
 exports.useWalletConnection = useWalletConnection;
 exports.useWalletModalState = useWalletModalState;
 exports.useWalletSession = useWalletSession;
-exports.useWalletStandardConnectors = useWalletStandardConnectors;
 //# sourceMappingURL=index.browser.cjs.map
 //# sourceMappingURL=index.browser.cjs.map