@solana/react-hooks 0.2.5 → 0.5.0

package/dist/index.browser.cjs

@@ -6,15 +6,6 @@ var jsxRuntime = require('react/jsx-runtime');
 var useSWR = require('swr');
 var zustand = require('zustand');
 var kit = require('@solana/kit');
-var addresses = require('@solana/addresses');
-var errors$1 = require('@solana/errors');
-var promises = require('@solana/promises');
-var transactionMessages = require('@solana/transaction-messages');
-var transactions = require('@solana/transactions');
-var walletStandardFeatures = require('@solana/wallet-standard-features');
-var errors = require('@wallet-standard/errors');
-var ui = require('@wallet-standard/ui');
-var uiRegistry = require('@wallet-standard/ui-registry');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -71,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(() => {
@@ -84,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,
@@ -146,31 +183,33 @@ function useLatestBlockhash(options) {
 }
 __name(useLatestBlockhash, "useLatestBlockhash");
 function useProgramAccounts(programAddress, options) {
-  const { commitment, config, ...queryOptions } = options ?? {};
-  const { disabled: disabledOption, ...restQueryOptions } = queryOptions;
-  const address2 = react.useMemo(() => programAddress ? client.toAddress(programAddress) : void 0, [programAddress]);
-  const addressKey = react.useMemo(() => address2 ? client.toAddressString(address2) : null, [address2]);
-  const configKey = react.useMemo(() => client.stableStringify(config ?? null), [config]);
+  const { commitment, config, swr, disabled: disabledOption } = options ?? {};
   const fetcher = react.useCallback(
-    async (client) => {
-      if (!address2) {
+    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(address2, mergedConfig);
+      const plan = client$1.runtime.rpc.getProgramAccounts(address, mergedConfig);
       return plan.send({ abortSignal: AbortSignal.timeout(2e4) });
     },
-    [address2, commitment, config]
+    [commitment, config, programAddress]
+  );
+  const disabled = disabledOption ?? !programAddress;
+  const query = useSolanaRpcQuery(
+    "programAccounts",
+    getProgramAccountsKey({ programAddress, config }),
+    fetcher,
+    {
+      disabled,
+      swr
+    }
   );
-  const disabled = disabledOption ?? !address2;
-  const query = useSolanaRpcQuery("programAccounts", [addressKey, configKey], fetcher, {
-    ...restQueryOptions,
-    disabled
-  });
   return {
     ...query,
     accounts: query.data ?? []
@@ -178,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;
@@ -189,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) {
@@ -205,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() {
@@ -367,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;
@@ -433,42 +491,42 @@ __name(useSplToken, "useSplToken");
 function useAccount(addressLike, options = {}) {
   const client$1 = useSolanaClient();
   const shouldSkip = options.skip ?? !addressLike;
-  const address2 = react.useMemo(() => {
+  const address = react.useMemo(() => {
     if (shouldSkip || !addressLike) {
       return void 0;
     }
     return client.toAddress(addressLike);
   }, [addressLike, shouldSkip]);
-  const accountKey = react.useMemo(() => address2?.toString(), [address2]);
+  const accountKey = react.useMemo(() => address?.toString(), [address]);
   const selector = react.useMemo(() => createAccountSelector(accountKey), [accountKey]);
   const account = useClientStore(selector);
   useSuspenseFetcher({
-    enabled: options.fetch !== false && !shouldSkip && Boolean(address2),
+    enabled: options.fetch !== false && !shouldSkip && Boolean(address),
     fetcher: /* @__PURE__ */ __name(() => {
-      if (!address2) {
+      if (!address) {
         throw new Error("Provide an address before fetching account data.");
       }
-      return client$1.actions.fetchAccount(address2, options.commitment);
+      return client$1.actions.fetchAccount(address, options.commitment);
     }, "fetcher"),
     key: accountKey ?? null,
     ready: account !== void 0
   });
   react.useEffect(() => {
-    if (!address2) {
+    if (!address) {
       return;
     }
     const commitment = options.commitment;
     if (options.fetch !== false && account === void 0) {
-      void client$1.actions.fetchAccount(address2, commitment).catch(() => void 0);
+      void client$1.actions.fetchAccount(address, commitment).catch(() => void 0);
     }
     if (options.watch) {
-      const subscription = client$1.watchers.watchAccount({ address: address2, commitment }, () => void 0);
+      const subscription = client$1.watchers.watchAccount({ address, commitment }, () => void 0);
       return () => {
         subscription.abort();
       };
     }
     return void 0;
-  }, [account, address2, client$1, options.commitment, options.fetch, options.watch]);
+  }, [account, address, client$1, options.commitment, options.fetch, options.watch]);
   return account;
 }
 __name(useAccount, "useAccount");
@@ -484,42 +542,42 @@ function useBalance(addressLike, options = {}) {
   );
   const client$1 = useSolanaClient();
   const shouldSkip = mergedOptions.skip ?? !addressLike;
-  const address2 = react.useMemo(() => {
+  const address = react.useMemo(() => {
     if (shouldSkip || !addressLike) {
       return void 0;
     }
     return client.toAddress(addressLike);
   }, [addressLike, shouldSkip]);
-  const accountKey = react.useMemo(() => address2?.toString(), [address2]);
+  const accountKey = react.useMemo(() => address?.toString(), [address]);
   const selector = react.useMemo(() => createAccountSelector(accountKey), [accountKey]);
   const account = useClientStore(selector);
   useSuspenseFetcher({
-    enabled: mergedOptions.fetch !== false && !shouldSkip && Boolean(address2),
+    enabled: mergedOptions.fetch !== false && !shouldSkip && Boolean(address),
     fetcher: /* @__PURE__ */ __name(() => {
-      if (!address2) {
+      if (!address) {
         throw new Error("Provide an address before fetching balance.");
       }
-      return client$1.actions.fetchBalance(address2, mergedOptions.commitment);
+      return client$1.actions.fetchBalance(address, mergedOptions.commitment);
     }, "fetcher"),
     key: accountKey ?? null,
     ready: account !== void 0
   });
   react.useEffect(() => {
-    if (!address2) {
+    if (!address) {
       return;
     }
     const commitment = mergedOptions.commitment;
     if (mergedOptions.fetch !== false && account === void 0) {
-      void client$1.actions.fetchBalance(address2, commitment).catch(() => void 0);
+      void client$1.actions.fetchBalance(address, commitment).catch(() => void 0);
     }
     if (mergedOptions.watch) {
-      const watcher = client$1.watchers.watchBalance({ address: address2, commitment }, () => void 0);
+      const watcher = client$1.watchers.watchBalance({ address, commitment }, () => void 0);
       return () => {
         watcher.abort();
       };
     }
     return void 0;
-  }, [account, address2, client$1, mergedOptions.commitment, mergedOptions.fetch, mergedOptions.watch]);
+  }, [account, address, client$1, mergedOptions.commitment, mergedOptions.fetch, mergedOptions.watch]);
   const lamports = account?.lamports ?? null;
   const fetching = account?.fetching ?? false;
   const slot = account?.slot;
@@ -536,22 +594,6 @@ function useBalance(addressLike, options = {}) {
   );
 }
 __name(useBalance, "useBalance");
-function useWalletStandardConnectors(options) {
-  const overrides = options?.overrides;
-  const memoisedOptions = react.useMemo(() => overrides ? { overrides } : void 0, [overrides]);
-  const [connectors, setConnectors] = react.useState(
-    () => client.getWalletStandardConnectors(memoisedOptions ?? {})
-  );
-  react.useEffect(() => {
-    setConnectors(client.getWalletStandardConnectors(memoisedOptions ?? {}));
-    const unwatch = client.watchWalletStandardConnectors(setConnectors, memoisedOptions ?? {});
-    return () => {
-      unwatch();
-    };
-  }, [memoisedOptions]);
-  return connectors;
-}
-__name(useWalletStandardConnectors, "useWalletStandardConnectors");
 function useTransactionPool(config = {}) {
   const initialInstructions = react.useMemo(
     () => config.instructions ?? [],
@@ -685,10 +727,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) {
@@ -703,14 +744,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);
@@ -729,14 +770,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);
@@ -792,10 +836,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({
@@ -842,6 +887,10 @@ function SolanaProvider({ children, client, config, query, walletPersistence })
   const shouldIncludeQueryLayer = query !== false && query?.disabled !== true;
   const queryProps = shouldIncludeQueryLayer && query ? query : {};
   const persistenceConfig = walletPersistence === false ? void 0 : walletPersistence ?? {};
+  const storage = persistenceConfig ? persistenceConfig.storage ?? getDefaultStorage() : null;
+  const storageKey = persistenceConfig?.storageKey ?? DEFAULT_STORAGE_KEY;
+  const persistedState = persistenceConfig ? readPersistedState(storage, storageKey) : { legacyConnectorId: null, state: null };
+  const clientConfig = config && persistenceConfig ? { ...config, initialState: config.initialState ?? persistedState.state ?? void 0 } : config;
   const content = shouldIncludeQueryLayer ? /* @__PURE__ */ jsxRuntime.jsx(
     SolanaQueryProvider,
     {
@@ -851,46 +900,77 @@ function SolanaProvider({ children, client, config, query, walletPersistence })
       children
     }
   ) : children;
-  return /* @__PURE__ */ jsxRuntime.jsxs(SolanaClientProvider, { client, config, children: [
-    persistenceConfig ? /* @__PURE__ */ jsxRuntime.jsx(WalletPersistence, { ...persistenceConfig }) : null,
+  return /* @__PURE__ */ jsxRuntime.jsxs(SolanaClientProvider, { client, config: clientConfig, children: [
+    persistenceConfig ? /* @__PURE__ */ jsxRuntime.jsx(
+      WalletPersistence,
+      {
+        autoConnect: persistenceConfig.autoConnect,
+        initialState: clientConfig?.initialState ?? persistedState.state,
+        legacyConnectorId: persistedState.legacyConnectorId,
+        storage,
+        storageKey
+      }
+    ) : null,
     content
   ] });
 }
 __name(SolanaProvider, "SolanaProvider");
 var DEFAULT_STORAGE_KEY = "solana:last-connector";
-function WalletPersistence({ autoConnect = true, storage, storageKey = DEFAULT_STORAGE_KEY }) {
+function readPersistedState(storage, storageKey) {
+  if (!storage) {
+    return { legacyConnectorId: null, state: null };
+  }
+  const raw = safelyRead(() => storage.getItem(storageKey));
+  if (!raw) {
+    return { legacyConnectorId: null, state: null };
+  }
+  const parsed = client.deserializeSolanaState(raw);
+  if (parsed) {
+    return { legacyConnectorId: null, state: parsed };
+  }
+  return { legacyConnectorId: raw, state: null };
+}
+__name(readPersistedState, "readPersistedState");
+function WalletPersistence({
+  autoConnect = true,
+  initialState = null,
+  legacyConnectorId = null,
+  storage,
+  storageKey = DEFAULT_STORAGE_KEY
+}) {
   const wallet = useWallet();
   const connectWallet = useConnectWallet();
-  const client = useSolanaClient();
+  const client$1 = useSolanaClient();
   const storageRef = react.useRef(storage ?? getDefaultStorage());
   const [hasAttemptedAutoConnect, setHasAttemptedAutoConnect] = react.useState(false);
-  const hasPersistedConnectorRef = react.useRef(false);
   const clientRef = react.useRef(null);
+  const persistedStateRef = react.useRef(initialState);
+  const legacyConnectorIdRef = react.useRef(legacyConnectorId);
   react.useEffect(() => {
     storageRef.current = storage ?? getDefaultStorage();
   }, [storage]);
   react.useEffect(() => {
-    if (clientRef.current !== client) {
-      clientRef.current = client;
+    if (clientRef.current !== client$1) {
+      clientRef.current = client$1;
       setHasAttemptedAutoConnect(false);
     }
-  }, [client]);
+  }, [client$1]);
   react.useEffect(() => {
     const activeStorage = storageRef.current;
     if (!activeStorage) return;
-    if ("connectorId" in wallet && wallet.connectorId) {
-      const connectorId = wallet.connectorId;
-      if (connectorId) {
-        safelyWrite(() => activeStorage.setItem(storageKey, connectorId));
-        hasPersistedConnectorRef.current = true;
-        return;
-      }
-    }
-    if (wallet.status === "disconnected" && hasPersistedConnectorRef.current) {
-      safelyWrite(() => activeStorage.removeItem(storageKey));
-      hasPersistedConnectorRef.current = false;
-    }
-  }, [storageKey, wallet]);
+    const unsubscribe = client.subscribeSolanaState(client$1, (state) => {
+      persistedStateRef.current = state;
+      legacyConnectorIdRef.current = null;
+      safelyWrite(() => activeStorage.setItem(storageKey, client.serializeSolanaState(state)));
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [client$1, storageKey]);
+  react.useEffect(() => {
+    persistedStateRef.current = initialState ?? persistedStateRef.current;
+    legacyConnectorIdRef.current = legacyConnectorId;
+  }, [initialState, legacyConnectorId]);
   react.useEffect(() => {
     if (!autoConnect || hasAttemptedAutoConnect) {
       return;
@@ -899,35 +979,21 @@ function WalletPersistence({ autoConnect = true, storage, storageKey = DEFAULT_S
       setHasAttemptedAutoConnect(true);
       return;
     }
-    const activeStorage = storageRef.current;
-    if (!activeStorage) {
-      setHasAttemptedAutoConnect(true);
-      return;
-    }
-    let cancelled = false;
-    const connectorId = safelyRead(() => activeStorage.getItem(storageKey));
-    if (!connectorId) {
-      setHasAttemptedAutoConnect(true);
-      return;
-    }
-    const connector = client.connectors.get(connectorId);
-    if (!connector) {
-      return;
-    }
+    const state = persistedStateRef.current ?? initialState;
+    const connectorId = state?.lastConnectorId ?? legacyConnectorIdRef.current;
+    const shouldAutoConnect = (state?.autoconnect ?? autoConnect) && connectorId;
+    if (!shouldAutoConnect || !connectorId) return;
+    const connector = client$1.connectors.get(connectorId);
+    if (!connector) return;
     void (async () => {
       try {
         await connectWallet(connectorId, { autoConnect: true });
       } catch {
       } finally {
-        if (!cancelled) {
-          setHasAttemptedAutoConnect(true);
-        }
+        setHasAttemptedAutoConnect(true);
       }
     })();
-    return () => {
-      cancelled = true;
-    };
-  }, [autoConnect, client, connectWallet, hasAttemptedAutoConnect, storageKey, wallet.status]);
+  }, [autoConnect, client$1, connectWallet, hasAttemptedAutoConnect, initialState, wallet.status]);
   return null;
 }
 __name(WalletPersistence, "WalletPersistence");
@@ -961,8 +1027,8 @@ function useWalletConnection(options = {}) {
   const wallet = useWallet();
   const connectWallet = useConnectWallet();
   const disconnectWallet = useDisconnectWallet();
-  const discovered = useWalletStandardConnectors(options.discoveryOptions);
-  const connectors = options.connectors ?? discovered;
+  const client = useSolanaClient();
+  const connectors = options.connectors ?? client.connectors.all;
   const connect = react.useCallback(
     (connectorId, connectOptions) => connectWallet(connectorId, connectOptions),
     [connectWallet]
@@ -970,6 +1036,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 {
@@ -978,6 +1045,7 @@ function useWalletConnection(options = {}) {
       connecting: wallet.status === "connecting",
       connectors,
       connectorId,
+      currentConnector,
       disconnect,
       error,
       status: wallet.status,
@@ -987,8 +1055,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");
@@ -1023,338 +1091,15 @@ function useWalletModalState(options = {}) {
   };
 }
 __name(useWalletModalState, "useWalletModalState");
-function useSignAndSendTransaction(uiWalletAccount, chain) {
-  const signAndSendTransactions = useSignAndSendTransactions(uiWalletAccount, chain);
-  return react.useCallback(
-    async (input) => {
-      const [result] = await signAndSendTransactions(input);
-      return result;
-    },
-    [signAndSendTransactions]
-  );
-}
-__name(useSignAndSendTransaction, "useSignAndSendTransaction");
-function useSignAndSendTransactions(uiWalletAccount, chain) {
-  if (!uiWalletAccount.chains.includes(chain)) {
-    throw new errors.WalletStandardError(errors.WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED, {
-      address: uiWalletAccount.address,
-      chain,
-      featureName: walletStandardFeatures.SolanaSignAndSendTransaction,
-      supportedChains: [...uiWalletAccount.chains],
-      supportedFeatures: [...uiWalletAccount.features]
-    });
-  }
-  const signAndSendTransactionFeature = ui.getWalletAccountFeature(
-    uiWalletAccount,
-    walletStandardFeatures.SolanaSignAndSendTransaction
-  );
-  const account = uiRegistry.getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
-  return react.useCallback(
-    async (...inputs) => {
-      const inputsWithChainAndAccount = inputs.map(({ options, ...rest }) => {
-        const minContextSlot = options?.minContextSlot;
-        return {
-          ...rest,
-          account,
-          chain,
-          ...minContextSlot != null ? {
-            options: {
-              minContextSlot: Number(minContextSlot)
-            }
-          } : null
-        };
-      });
-      const results = await signAndSendTransactionFeature.signAndSendTransaction(...inputsWithChainAndAccount);
-      return results;
-    },
-    [account, chain, signAndSendTransactionFeature]
-  );
-}
-__name(useSignAndSendTransactions, "useSignAndSendTransactions");
-function useSignIn(uiWalletHandle) {
-  const signIns = useSignIns(uiWalletHandle);
-  return react.useCallback(
-    async (input) => {
-      const [result] = await signIns(input);
-      return result;
-    },
-    [signIns]
-  );
-}
-__name(useSignIn, "useSignIn");
-function useSignIns(uiWalletHandle) {
-  let signMessageFeature;
-  if ("address" in uiWalletHandle && typeof uiWalletHandle.address === "string") {
-    uiRegistry.getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletHandle);
-    signMessageFeature = ui.getWalletAccountFeature(
-      uiWalletHandle,
-      walletStandardFeatures.SolanaSignIn
-    );
-  } else {
-    signMessageFeature = ui.getWalletFeature(uiWalletHandle, walletStandardFeatures.SolanaSignIn);
-  }
-  const wallet = uiRegistry.getWalletForHandle_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletHandle);
-  return react.useCallback(
-    async (...inputs) => {
-      const inputsWithAddressAndChainId = inputs.map((input) => ({
-        ...input,
-        // Prioritize the `UiWalletAccount` address if it exists.
-        ..."address" in uiWalletHandle ? { address: uiWalletHandle.address } : null
-      }));
-      const results = await signMessageFeature.signIn(...inputsWithAddressAndChainId);
-      const resultsWithoutSignatureType = results.map(
-        ({
-          account,
-          signatureType: _signatureType,
-          // Solana signatures are always of type `ed25519` so drop this property.
-          ...rest
-        }) => ({
-          ...rest,
-          account: uiRegistry.getOrCreateUiWalletAccountForStandardWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(
-            wallet,
-            account
-          )
-        })
-      );
-      return resultsWithoutSignatureType;
-    },
-    [signMessageFeature, uiWalletHandle, wallet]
-  );
-}
-__name(useSignIns, "useSignIns");
-function useSignMessage(...config) {
-  const signMessages = useSignMessages(...config);
-  return react.useCallback(
-    async (input) => {
-      const [result] = await signMessages(input);
-      return result;
-    },
-    [signMessages]
-  );
-}
-__name(useSignMessage, "useSignMessage");
-function useSignMessages(uiWalletAccount) {
-  const signMessageFeature = ui.getWalletAccountFeature(
-    uiWalletAccount,
-    walletStandardFeatures.SolanaSignMessage
-  );
-  const account = uiRegistry.getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
-  return react.useCallback(
-    async (...inputs) => {
-      const inputsWithAccount = inputs.map((input) => ({ ...input, account }));
-      const results = await signMessageFeature.signMessage(...inputsWithAccount);
-      const resultsWithoutSignatureType = results.map(
-        ({
-          signatureType: _signatureType,
-          // Solana signatures are always of type `ed25519` so drop this property.
-          ...rest
-        }) => rest
-      );
-      return resultsWithoutSignatureType;
-    },
-    [signMessageFeature, account]
-  );
-}
-__name(useSignMessages, "useSignMessages");
-function useSignTransaction(uiWalletAccount, chain) {
-  const signTransactions = useSignTransactions(uiWalletAccount, chain);
-  return react.useCallback(
-    async (input) => {
-      const [result] = await signTransactions(input);
-      return result;
-    },
-    [signTransactions]
-  );
-}
-__name(useSignTransaction, "useSignTransaction");
-function useSignTransactions(uiWalletAccount, chain) {
-  if (!uiWalletAccount.chains.includes(chain)) {
-    throw new errors.WalletStandardError(errors.WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED, {
-      address: uiWalletAccount.address,
-      chain,
-      featureName: walletStandardFeatures.SolanaSignAndSendTransaction,
-      supportedChains: [...uiWalletAccount.chains],
-      supportedFeatures: [...uiWalletAccount.features]
-    });
-  }
-  const signTransactionFeature = ui.getWalletAccountFeature(
-    uiWalletAccount,
-    walletStandardFeatures.SolanaSignTransaction
-  );
-  const account = uiRegistry.getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
-  return react.useCallback(
-    async (...inputs) => {
-      const inputsWithAccountAndChain = inputs.map(({ options, ...rest }) => {
-        const minContextSlot = options?.minContextSlot;
-        return {
-          ...rest,
-          account,
-          chain,
-          ...minContextSlot != null ? {
-            options: {
-              minContextSlot: Number(minContextSlot)
-            }
-          } : null
-        };
-      });
-      const results = await signTransactionFeature.signTransaction(...inputsWithAccountAndChain);
-      return results;
-    },
-    [signTransactionFeature, account, chain]
-  );
-}
-__name(useSignTransactions, "useSignTransactions");
-function useWalletAccountMessageSigner(uiWalletAccount) {
-  const signMessage = useSignMessage(uiWalletAccount);
-  return react.useMemo(
-    () => ({
-      address: addresses.address(uiWalletAccount.address),
-      async modifyAndSignMessages(messages, config) {
-        config?.abortSignal?.throwIfAborted();
-        if (messages.length > 1) {
-          throw new errors$1.SolanaError(errors$1.SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
-        }
-        if (messages.length === 0) {
-          return messages;
-        }
-        const { content: originalMessage, signatures: originalSignatureMap } = messages[0];
-        const input = {
-          message: originalMessage
-        };
-        const { signedMessage, signature } = await promises.getAbortablePromise(signMessage(input), config?.abortSignal);
-        const messageWasModified = originalMessage.length !== signedMessage.length || originalMessage.some((originalByte, ii) => originalByte !== signedMessage[ii]);
-        const originalSignature = originalSignatureMap[uiWalletAccount.address];
-        const signatureIsNew = !originalSignature?.every((originalByte, ii) => originalByte === signature[ii]);
-        if (!signatureIsNew && !messageWasModified) {
-          return messages;
-        }
-        const nextSignatureMap = messageWasModified ? { [uiWalletAccount.address]: signature } : { ...originalSignatureMap, [uiWalletAccount.address]: signature };
-        const outputMessages = Object.freeze([
-          Object.freeze({
-            content: signedMessage,
-            signatures: Object.freeze(nextSignatureMap)
-          })
-        ]);
-        return outputMessages;
-      }
-    }),
-    [uiWalletAccount, signMessage]
-  );
-}
-__name(useWalletAccountMessageSigner, "useWalletAccountMessageSigner");
-function useWalletAccountTransactionSigner(uiWalletAccount, chain) {
-  const encoderRef = react.useRef(null);
-  const signTransaction = useSignTransaction(uiWalletAccount, chain);
-  return react.useMemo(
-    () => ({
-      address: addresses.address(uiWalletAccount.address),
-      async modifyAndSignTransactions(transactions$1, config = {}) {
-        const { abortSignal, ...options } = config;
-        abortSignal?.throwIfAborted();
-        let transactionCodec = encoderRef.current;
-        if (!transactionCodec) {
-          transactionCodec = transactions.getTransactionCodec();
-          encoderRef.current = transactionCodec;
-        }
-        if (transactions$1.length > 1) {
-          throw new errors$1.SolanaError(errors$1.SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
-        }
-        if (transactions$1.length === 0) {
-          return transactions$1;
-        }
-        const [transaction] = transactions$1;
-        const wireTransactionBytes = transactionCodec.encode(transaction);
-        const inputWithOptions = {
-          ...options,
-          transaction: wireTransactionBytes
-        };
-        const { signedTransaction } = await promises.getAbortablePromise(signTransaction(inputWithOptions), abortSignal);
-        const decodedSignedTransaction = transactionCodec.decode(
-          signedTransaction
-        );
-        transactions.assertIsTransactionWithinSizeLimit(decodedSignedTransaction);
-        const existingLifetime = "lifetimeConstraint" in transaction ? transaction.lifetimeConstraint : void 0;
-        if (existingLifetime) {
-          if (uint8ArraysEqual(decodedSignedTransaction.messageBytes, transaction.messageBytes)) {
-            return Object.freeze([
-              {
-                ...decodedSignedTransaction,
-                lifetimeConstraint: existingLifetime
-              }
-            ]);
-          }
-          const compiledTransactionMessage2 = transactionMessages.getCompiledTransactionMessageDecoder().decode(
-            decodedSignedTransaction.messageBytes
-          );
-          const currentToken = "blockhash" in existingLifetime ? existingLifetime.blockhash : existingLifetime.nonce;
-          if (compiledTransactionMessage2.lifetimeToken === currentToken) {
-            return Object.freeze([
-              {
-                ...decodedSignedTransaction,
-                lifetimeConstraint: existingLifetime
-              }
-            ]);
-          }
-        }
-        const compiledTransactionMessage = transactionMessages.getCompiledTransactionMessageDecoder().decode(
-          decodedSignedTransaction.messageBytes
-        );
-        const lifetimeConstraint = await transactions.getTransactionLifetimeConstraintFromCompiledTransactionMessage(compiledTransactionMessage);
-        return Object.freeze([
-          {
-            ...decodedSignedTransaction,
-            lifetimeConstraint
-          }
-        ]);
-      }
-    }),
-    [uiWalletAccount.address, signTransaction]
-  );
-}
-__name(useWalletAccountTransactionSigner, "useWalletAccountTransactionSigner");
-function uint8ArraysEqual(arr1, arr2) {
-  return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
-}
-__name(uint8ArraysEqual, "uint8ArraysEqual");
-function useWalletAccountTransactionSendingSigner(uiWalletAccount, chain) {
-  const encoderRef = react.useRef(null);
-  const signAndSendTransaction = useSignAndSendTransaction(uiWalletAccount, chain);
-  return react.useMemo(
-    () => ({
-      address: addresses.address(uiWalletAccount.address),
-      async signAndSendTransactions(transactions$1, config = {}) {
-        const { abortSignal, ...options } = config;
-        abortSignal?.throwIfAborted();
-        let transactionEncoder = encoderRef.current;
-        if (!transactionEncoder) {
-          transactionEncoder = transactions.getTransactionEncoder();
-          encoderRef.current = transactionEncoder;
-        }
-        if (transactions$1.length > 1) {
-          throw new errors$1.SolanaError(errors$1.SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
-        }
-        if (transactions$1.length === 0) {
-          return [];
-        }
-        const [transaction] = transactions$1;
-        const wireTransactionBytes = transactionEncoder.encode(transaction);
-        const inputWithOptions = {
-          ...options,
-          transaction: wireTransactionBytes
-        };
-        const { signature } = await promises.getAbortablePromise(signAndSendTransaction(inputWithOptions), abortSignal);
-        return Object.freeze([signature]);
-      }
-    }),
-    [signAndSendTransaction, uiWalletAccount.address]
-  );
-}
-__name(useWalletAccountTransactionSendingSigner, "useWalletAccountTransactionSendingSigner");
 
 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;
@@ -1365,10 +1110,6 @@ exports.useDisconnectWallet = useDisconnectWallet;
 exports.useLatestBlockhash = useLatestBlockhash;
 exports.useProgramAccounts = useProgramAccounts;
 exports.useSendTransaction = useSendTransaction;
-exports.useSignAndSendTransaction = useSignAndSendTransaction;
-exports.useSignIn = useSignIn;
-exports.useSignMessage = useSignMessage;
-exports.useSignTransaction = useSignTransaction;
 exports.useSignatureStatus = useSignatureStatus;
 exports.useSimulateTransaction = useSimulateTransaction;
 exports.useSolTransfer = useSolTransfer;
@@ -1377,13 +1118,9 @@ exports.useSplToken = useSplToken;
 exports.useTransactionPool = useTransactionPool;
 exports.useWaitForSignature = useWaitForSignature;
 exports.useWallet = useWallet;
-exports.useWalletAccountMessageSigner = useWalletAccountMessageSigner;
-exports.useWalletAccountTransactionSendingSigner = useWalletAccountTransactionSendingSigner;
-exports.useWalletAccountTransactionSigner = useWalletAccountTransactionSigner;
 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