@solana/react-hooks 1.1.1 → 1.1.3

package/dist/index.browser.cjs

@@ -1,1253 +0,0 @@
-'use strict';
-
-var client = require('@solana/client');
-var react = require('react');
-var jsxRuntime = require('react/jsx-runtime');
-var useSWR = require('swr');
-var zustand = require('zustand');
-var kit = require('@solana/kit');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var SolanaClientContext = react.createContext(null);
-function normalizeConfig(config) {
-  return client.resolveClientConfig(config ?? {});
-}
-__name(normalizeConfig, "normalizeConfig");
-function SolanaClientProvider({ children, client: providedClient, config }) {
-  const normalizedConfig = react.useMemo(() => normalizeConfig(config), [config]);
-  const client$1 = react.useMemo(() => {
-    if (providedClient) {
-      return providedClient;
-    }
-    return client.createClient(normalizedConfig);
-  }, [normalizedConfig, providedClient]);
-  react.useEffect(() => {
-    if (providedClient) {
-      return;
-    }
-    return () => {
-      client$1.destroy();
-    };
-  }, [client$1, providedClient]);
-  return /* @__PURE__ */ jsxRuntime.jsx(SolanaClientContext.Provider, { value: client$1, children });
-}
-__name(SolanaClientProvider, "SolanaClientProvider");
-function useSolanaClient() {
-  const client = react.useContext(SolanaClientContext);
-  if (!client) {
-    throw new Error("useSolanaClient must be used within a SolanaClientProvider.");
-  }
-  return client;
-}
-__name(useSolanaClient, "useSolanaClient");
-var QuerySuspenseContext = react.createContext(void 0);
-function useQuerySuspensePreference() {
-  return react.useContext(QuerySuspenseContext);
-}
-__name(useQuerySuspensePreference, "useQuerySuspensePreference");
-var identitySelector = /* @__PURE__ */ __name((state) => state, "identitySelector");
-function useClientStore(selector) {
-  const client = useSolanaClient();
-  const appliedSelector = selector ?? identitySelector;
-  const slice = zustand.useStore(client.store, appliedSelector);
-  return selector ? slice : slice;
-}
-__name(useClientStore, "useClientStore");
-
-// src/query.ts
-var QUERY_NAMESPACE = "@solana/react-hooks";
-function useSolanaRpcQuery(scope, args, fetcher, options = {}) {
-  const client = useSolanaClient();
-  const cluster = useClientStore((state) => state.cluster);
-  const { disabled = false, swr } = options;
-  const providerSuspensePreference = useQuerySuspensePreference();
-  const suspenseEnabled = !disabled && Boolean(providerSuspensePreference);
-  const swrOptions = {
-    ...swr ?? {},
-    suspense: suspenseEnabled
-  };
-  const key = react.useMemo(() => {
-    if (disabled) {
-      return null;
-    }
-    return [QUERY_NAMESPACE, scope, cluster.endpoint, cluster.commitment, ...args];
-  }, [cluster.commitment, cluster.endpoint, args, scope, disabled]);
-  const swrResponse = useSWR__default.default(key, () => fetcher(client), swrOptions);
-  const [dataUpdatedAt, setDataUpdatedAt] = react.useState(
-    () => swrResponse.data !== void 0 ? Date.now() : void 0
-  );
-  react.useEffect(() => {
-    if (swrResponse.data !== void 0) {
-      setDataUpdatedAt(Date.now());
-    }
-  }, [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: swrResponse.data,
-    dataUpdatedAt,
-    error: swrResponse.error ?? null,
-    isError: status === "error",
-    isLoading: swrResponse.isLoading,
-    isSuccess: status === "success",
-    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,
-    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: normalizeMinContextSlot(minContextSlot)
-      });
-      return plan.send({ abortSignal: AbortSignal.timeout(15e3) });
-    },
-    [commitment, minContextSlot]
-  );
-  const query = useSolanaRpcQuery(
-    "latestBlockhash",
-    getLatestBlockhashKey(options),
-    fetcher,
-    {
-      disabled,
-      swr: {
-        refreshInterval,
-        ...swr
-      }
-    }
-  );
-  return {
-    ...query,
-    blockhash: query.data?.value.blockhash ?? null,
-    contextSlot: query.data?.context.slot,
-    lastValidBlockHeight: query.data?.value.lastValidBlockHeight ?? null
-  };
-}
-__name(useLatestBlockhash, "useLatestBlockhash");
-function useProgramAccounts(programAddress, options) {
-  const { commitment, config, swr, disabled: disabledOption } = options ?? {};
-  const fetcher = react.useCallback(
-    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$1.store.getState().cluster.commitment;
-      const mergedConfig = {
-        ...config ?? {},
-        commitment: fallbackCommitment
-      };
-      const plan = client$1.runtime.rpc.getProgramAccounts(address, mergedConfig);
-      return plan.send({ abortSignal: AbortSignal.timeout(2e4) });
-    },
-    [commitment, config, programAddress]
-  );
-  const disabled = disabledOption ?? !programAddress;
-  const query = useSolanaRpcQuery(
-    "programAccounts",
-    getProgramAccountsKey({ programAddress, config }),
-    fetcher,
-    {
-      disabled,
-      swr
-    }
-  );
-  return {
-    ...query,
-    accounts: query.data ?? []
-  };
-}
-__name(useProgramAccounts, "useProgramAccounts");
-function useSimulateTransaction(transaction, options) {
-  const { commitment, config, refreshInterval, disabled: disabledOption, swr } = options ?? {};
-  const wire = react.useMemo(() => {
-    if (!transaction) {
-      return null;
-    }
-    if (typeof transaction === "string") {
-      return transaction;
-    }
-    return kit.getBase64EncodedWireTransaction(transaction);
-  }, [transaction]);
-  const fetcher = react.useCallback(
-    async (client) => {
-      if (!wire) {
-        throw new Error("Provide a transaction payload before simulating.");
-      }
-      const resolvedConfig = {
-        ...config ?? {},
-        commitment: commitment ?? config?.commitment ?? client.store.getState().cluster.commitment
-      };
-      const plan = client.runtime.rpc.simulateTransaction(wire, resolvedConfig);
-      return plan.send({ abortSignal: AbortSignal.timeout(2e4) });
-    },
-    [commitment, config, wire]
-  );
-  const disabled = disabledOption ?? !wire;
-  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() {
-  return (state) => state.cluster;
-}
-__name(createClusterSelector, "createClusterSelector");
-function createClusterStatusSelector() {
-  return (state) => state.cluster.status;
-}
-__name(createClusterStatusSelector, "createClusterStatusSelector");
-function createWalletSelector() {
-  return (state) => state.wallet;
-}
-__name(createWalletSelector, "createWalletSelector");
-function createAccountSelector(key) {
-  return (state) => key ? state.accounts[key] : void 0;
-}
-__name(createAccountSelector, "createAccountSelector");
-function useSuspenseFetcher(config) {
-  const preference = useQuerySuspensePreference();
-  const suspenseEnabled = Boolean(preference) && config.enabled;
-  const pendingRef = react.useRef(null);
-  react.useEffect(() => {
-    if (!suspenseEnabled) {
-      pendingRef.current = null;
-      return;
-    }
-    if (pendingRef.current && pendingRef.current.key !== config.key) {
-      pendingRef.current = null;
-    }
-  }, [config.key, suspenseEnabled]);
-  if (pendingRef.current && pendingRef.current.key !== config.key) {
-    pendingRef.current = null;
-  }
-  if (suspenseEnabled && config.key && !config.ready) {
-    if (!pendingRef.current) {
-      const promise = config.fetcher();
-      pendingRef.current = {
-        key: config.key,
-        promise: promise.finally(() => {
-          if (pendingRef.current?.promise === promise) {
-            pendingRef.current = null;
-          }
-        })
-      };
-    }
-    throw pendingRef.current.promise;
-  }
-}
-__name(useSuspenseFetcher, "useSuspenseFetcher");
-function useClusterState() {
-  const selector = react.useMemo(createClusterSelector, []);
-  return useClientStore(selector);
-}
-__name(useClusterState, "useClusterState");
-function useClusterStatus() {
-  const selector = react.useMemo(createClusterStatusSelector, []);
-  return useClientStore(selector);
-}
-__name(useClusterStatus, "useClusterStatus");
-function useWallet() {
-  const selector = react.useMemo(createWalletSelector, []);
-  return useClientStore(selector);
-}
-__name(useWallet, "useWallet");
-function useWalletSession() {
-  const wallet = useWallet();
-  if (wallet.status === "connected") {
-    return wallet.session;
-  }
-  return void 0;
-}
-__name(useWalletSession, "useWalletSession");
-function useWalletActions() {
-  const client = useSolanaClient();
-  return client.actions;
-}
-__name(useWalletActions, "useWalletActions");
-function useConnectWallet() {
-  const client = useSolanaClient();
-  return react.useCallback(
-    (connectorId, options) => client.actions.connectWallet(connectorId, options),
-    [client]
-  );
-}
-__name(useConnectWallet, "useConnectWallet");
-function useDisconnectWallet() {
-  const client = useSolanaClient();
-  return react.useCallback(() => client.actions.disconnectWallet(), [client]);
-}
-__name(useDisconnectWallet, "useDisconnectWallet");
-function useSolTransfer() {
-  const client$1 = useSolanaClient();
-  const session = useWalletSession();
-  const helper = client$1.solTransfer;
-  const sessionRef = react.useRef(session);
-  react.useEffect(() => {
-    sessionRef.current = session;
-  }, [session]);
-  const controller = react.useMemo(
-    () => client.createSolTransferController({
-      authorityProvider: /* @__PURE__ */ __name(() => sessionRef.current, "authorityProvider"),
-      helper
-    }),
-    [helper]
-  );
-  const state = react.useSyncExternalStore(
-    controller.subscribe,
-    controller.getState,
-    controller.getState
-  );
-  const send = react.useCallback(
-    (config, options) => controller.send(config, options),
-    [controller]
-  );
-  return {
-    error: state.error ?? null,
-    helper,
-    isSending: state.status === "loading",
-    reset: controller.reset,
-    send,
-    signature: state.data ?? null,
-    status: state.status
-  };
-}
-__name(useSolTransfer, "useSolTransfer");
-function useStake(validatorId) {
-  const client$1 = useSolanaClient();
-  const session = useWalletSession();
-  const helper = client$1.stake;
-  const sessionRef = react.useRef(session);
-  const normalizedValidatorId = react.useMemo(() => String(validatorId), [validatorId]);
-  react.useEffect(() => {
-    sessionRef.current = session;
-  }, [session]);
-  const controller = react.useMemo(
-    () => client.createStakeController({
-      authorityProvider: /* @__PURE__ */ __name(() => sessionRef.current, "authorityProvider"),
-      helper
-    }),
-    [helper]
-  );
-  const state = react.useSyncExternalStore(
-    controller.subscribe,
-    controller.getState,
-    controller.getState
-  );
-  const unstakeState = react.useSyncExternalStore(
-    controller.subscribeUnstake,
-    controller.getUnstakeState,
-    controller.getUnstakeState
-  );
-  const withdrawState = react.useSyncExternalStore(
-    controller.subscribeWithdraw,
-    controller.getWithdrawState,
-    controller.getWithdrawState
-  );
-  const stake = react.useCallback(
-    (config, options) => controller.stake({ ...config, validatorId: normalizedValidatorId }, options),
-    [controller, normalizedValidatorId]
-  );
-  const unstake = react.useCallback(
-    (config, options) => controller.unstake({ ...config }, options),
-    [controller]
-  );
-  const withdraw = react.useCallback(
-    (config, options) => controller.withdraw({ ...config }, options),
-    [controller]
-  );
-  const getStakeAccounts = react.useCallback(
-    async (wallet, validatorIdFilter) => {
-      if (!helper.getStakeAccounts) {
-        throw new Error(
-          "getStakeAccounts is not available. Make sure you have the latest version of @solana/client package."
-        );
-      }
-      const walletAddr = typeof wallet === "string" ? wallet : String(wallet);
-      const filterAddr = validatorIdFilter ? typeof validatorIdFilter === "string" ? validatorIdFilter : String(validatorIdFilter) : void 0;
-      return helper.getStakeAccounts(walletAddr, filterAddr);
-    },
-    [helper]
-  );
-  return {
-    error: state.error ?? null,
-    getStakeAccounts,
-    helper,
-    isStaking: state.status === "loading",
-    isUnstaking: unstakeState.status === "loading",
-    isWithdrawing: withdrawState.status === "loading",
-    reset: controller.reset,
-    resetUnstake: controller.resetUnstake,
-    resetWithdraw: controller.resetWithdraw,
-    stake,
-    unstake,
-    withdraw,
-    signature: state.data ?? null,
-    unstakeSignature: unstakeState.data ?? null,
-    withdrawSignature: withdrawState.data ?? null,
-    status: state.status,
-    unstakeStatus: unstakeState.status,
-    withdrawStatus: withdrawState.status,
-    unstakeError: unstakeState.error ?? null,
-    withdrawError: withdrawState.error ?? null,
-    validatorId: normalizedValidatorId
-  };
-}
-__name(useStake, "useStake");
-function useSplToken(mint, options = {}) {
-  const client$1 = useSolanaClient();
-  const session = useWalletSession();
-  const suspense = Boolean(useQuerySuspensePreference());
-  const normalizedMint = react.useMemo(() => String(mint), [mint]);
-  const helperConfig = react.useMemo(
-    () => ({
-      commitment: options.commitment,
-      mint: normalizedMint,
-      ...options.config ?? {}
-    }),
-    [normalizedMint, options.commitment, options.config]
-  );
-  const helper = react.useMemo(() => client$1.splToken(helperConfig), [client$1, helperConfig]);
-  const ownerRaw = options.owner ?? session?.account.address;
-  const owner = react.useMemo(() => ownerRaw ? String(ownerRaw) : null, [ownerRaw]);
-  const balanceKey = owner ? ["spl-balance", normalizedMint, owner, options.commitment ?? null] : null;
-  const fetchBalance = react.useCallback(() => {
-    if (!owner) {
-      throw new Error("Unable to fetch SPL balance without an owner.");
-    }
-    return helper.fetchBalance(owner, options.commitment);
-  }, [helper, owner, options.commitment]);
-  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;
-  }, [session]);
-  const ownerRef = react.useRef(owner);
-  react.useEffect(() => {
-    ownerRef.current = owner;
-  }, [owner]);
-  const controller = react.useMemo(
-    () => client.createSplTransferController({
-      authorityProvider: /* @__PURE__ */ __name(() => sessionRef.current ?? void 0, "authorityProvider"),
-      helper,
-      sourceOwnerProvider: /* @__PURE__ */ __name(() => ownerRef.current ?? void 0, "sourceOwnerProvider")
-    }),
-    [helper]
-  );
-  const sendState = react.useSyncExternalStore(
-    controller.subscribe,
-    controller.getState,
-    controller.getState
-  );
-  const refresh = react.useCallback(() => {
-    if (!owner) {
-      return Promise.resolve(void 0);
-    }
-    return mutate(() => helper.fetchBalance(owner, options.commitment), { revalidate: false });
-  }, [helper, mutate, owner, options.commitment]);
-  const send = react.useCallback(
-    async (config, sendOptions) => {
-      const signature = await controller.send(config, sendOptions);
-      if (owner) {
-        await mutate(() => helper.fetchBalance(owner, options.commitment), { revalidate: false });
-      }
-      return signature;
-    },
-    [controller, helper, mutate, options.commitment, owner]
-  );
-  const resetSend = react.useCallback(() => {
-    controller.reset();
-  }, [controller]);
-  const status = owner === null ? "disconnected" : error ? "error" : isLoading && !data ? "loading" : "ready";
-  return {
-    balance: data ?? null,
-    error: error ?? null,
-    helper,
-    isFetching: Boolean(owner) && (isLoading || isValidating),
-    isSending: sendState.status === "loading",
-    owner,
-    refresh,
-    refreshing: Boolean(owner) && isValidating,
-    resetSend,
-    send,
-    sendError: sendState.error ?? null,
-    sendSignature: sendState.data ?? null,
-    sendStatus: sendState.status,
-    status
-  };
-}
-__name(useSplToken, "useSplToken");
-function useAccount(addressLike, options = {}) {
-  const client$1 = useSolanaClient();
-  const shouldSkip = options.skip ?? !addressLike;
-  const address = react.useMemo(() => {
-    if (shouldSkip || !addressLike) {
-      return void 0;
-    }
-    return client.toAddress(addressLike);
-  }, [addressLike, shouldSkip]);
-  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(address),
-    fetcher: /* @__PURE__ */ __name(() => {
-      if (!address) {
-        throw new Error("Provide an address before fetching account data.");
-      }
-      return client$1.actions.fetchAccount(address, options.commitment);
-    }, "fetcher"),
-    key: accountKey ?? null,
-    ready: account !== void 0
-  });
-  react.useEffect(() => {
-    if (!address) {
-      return;
-    }
-    const commitment = options.commitment;
-    if (options.fetch !== false && account === void 0) {
-      void client$1.actions.fetchAccount(address, commitment).catch(() => void 0);
-    }
-    if (options.watch) {
-      const subscription = client$1.watchers.watchAccount({ address, commitment }, () => void 0);
-      return () => {
-        subscription.abort();
-      };
-    }
-    return void 0;
-  }, [account, address, client$1, options.commitment, options.fetch, options.watch]);
-  return account;
-}
-__name(useAccount, "useAccount");
-function useBalance(addressLike, options = {}) {
-  const mergedOptions = react.useMemo(
-    () => ({
-      commitment: options.commitment,
-      fetch: options.fetch ?? true,
-      skip: options.skip,
-      watch: options.watch ?? true
-    }),
-    [options.commitment, options.fetch, options.skip, options.watch]
-  );
-  const client$1 = useSolanaClient();
-  const shouldSkip = mergedOptions.skip ?? !addressLike;
-  const address = react.useMemo(() => {
-    if (shouldSkip || !addressLike) {
-      return void 0;
-    }
-    return client.toAddress(addressLike);
-  }, [addressLike, shouldSkip]);
-  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(address),
-    fetcher: /* @__PURE__ */ __name(() => {
-      if (!address) {
-        throw new Error("Provide an address before fetching balance.");
-      }
-      return client$1.actions.fetchBalance(address, mergedOptions.commitment);
-    }, "fetcher"),
-    key: accountKey ?? null,
-    ready: account !== void 0
-  });
-  react.useEffect(() => {
-    if (!address) {
-      return;
-    }
-    const commitment = mergedOptions.commitment;
-    if (mergedOptions.fetch !== false && account === void 0) {
-      void client$1.actions.fetchBalance(address, commitment).catch(() => void 0);
-    }
-    if (mergedOptions.watch) {
-      const watcher = client$1.watchers.watchBalance({ address, commitment }, () => void 0);
-      return () => {
-        watcher.abort();
-      };
-    }
-    return void 0;
-  }, [account, address, client$1, mergedOptions.commitment, mergedOptions.fetch, mergedOptions.watch]);
-  const lamports = account?.lamports ?? null;
-  const fetching = account?.fetching ?? false;
-  const slot = account?.slot;
-  const error = account?.error;
-  return react.useMemo(
-    () => ({
-      account,
-      error,
-      fetching,
-      lamports,
-      slot
-    }),
-    [account, error, fetching, lamports, slot]
-  );
-}
-__name(useBalance, "useBalance");
-function useTransactionPool(config = {}) {
-  const initialInstructions = react.useMemo(
-    () => config.instructions ?? [],
-    [config.instructions]
-  );
-  const client$1 = useSolanaClient();
-  const helper = client$1.helpers.transaction;
-  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,
-      helper,
-      initialInstructions
-    }),
-    [blockhashMaxAgeMs, helper, initialInstructions]
-  );
-  const latestBlockhash = useLatestBlockhash(config.latestBlockhash);
-  react.useEffect(() => {
-    const value = latestBlockhash.data?.value;
-    if (!value) {
-      controller.setLatestBlockhashCache(void 0);
-      return;
-    }
-    const cache = {
-      updatedAt: latestBlockhash.dataUpdatedAt ?? Date.now(),
-      value
-    };
-    controller.setLatestBlockhashCache(cache);
-  }, [controller, latestBlockhash.data, latestBlockhash.dataUpdatedAt]);
-  const instructions = react.useSyncExternalStore(
-    controller.subscribeInstructions,
-    controller.getInstructions,
-    controller.getInstructions
-  );
-  const prepared = react.useSyncExternalStore(
-    controller.subscribePrepared,
-    controller.getPrepared,
-    controller.getPrepared
-  );
-  const prepareState = react.useSyncExternalStore(
-    controller.subscribePrepareState,
-    controller.getPrepareState,
-    controller.getPrepareState
-  );
-  const sendState = react.useSyncExternalStore(
-    controller.subscribeSendState,
-    controller.getSendState,
-    controller.getSendState
-  );
-  return {
-    addInstruction: controller.addInstruction,
-    addInstructions: controller.addInstructions,
-    clearInstructions: controller.clearInstructions,
-    instructions,
-    isPreparing: prepareState.status === "loading",
-    isSending: sendState.status === "loading",
-    prepared,
-    prepare: controller.prepare,
-    prepareError: prepareState.error ?? null,
-    prepareStatus: prepareState.status,
-    removeInstruction: controller.removeInstruction,
-    replaceInstructions: controller.replaceInstructions,
-    reset: controller.reset,
-    send: controller.send,
-    sendError: sendState.error ?? null,
-    sendSignature: sendState.data ?? null,
-    sendStatus: sendState.status,
-    prepareAndSend: controller.prepareAndSend,
-    sign: controller.sign,
-    toWire: controller.toWire,
-    latestBlockhash
-  };
-}
-__name(useTransactionPool, "useTransactionPool");
-function useSendTransaction() {
-  const client$1 = useSolanaClient();
-  const helper = client$1.transaction;
-  const session = useWalletSession();
-  const [state, setState] = react.useState(
-    () => client.createInitialAsyncState()
-  );
-  const execute = react.useCallback(
-    async (operation) => {
-      setState(client.createAsyncState("loading"));
-      try {
-        const signature = await operation();
-        setState(client.createAsyncState("success", { data: signature }));
-        return signature;
-      } catch (error) {
-        setState(client.createAsyncState("error", { error }));
-        throw error;
-      }
-    },
-    []
-  );
-  const ensureAuthority = react.useCallback(
-    (request) => {
-      if (request.authority) {
-        return request;
-      }
-      if (!session) {
-        throw new Error("Connect a wallet or supply an `authority` before sending transactions.");
-      }
-      return { ...request, authority: session };
-    },
-    [session]
-  );
-  const send = react.useCallback(
-    async (request, options) => {
-      const normalizedRequest = ensureAuthority(request);
-      return execute(() => helper.prepareAndSend(normalizedRequest, options));
-    },
-    [ensureAuthority, execute, helper]
-  );
-  const sendPrepared = react.useCallback(
-    async (prepared, options) => execute(() => helper.send(prepared, options)),
-    [execute, helper]
-  );
-  const reset = react.useCallback(() => {
-    setState(client.createInitialAsyncState());
-  }, []);
-  return {
-    error: state.error ?? null,
-    isSending: state.status === "loading",
-    reset,
-    send,
-    sendPrepared,
-    signature: state.data ?? null,
-    status: state.status
-  };
-}
-__name(useSendTransaction, "useSendTransaction");
-function useSignatureStatus(signatureInput, options = {}) {
-  const { config, disabled: disabledOption, swr } = options;
-  const signature = react.useMemo(() => client.normalizeSignature(signatureInput), [signatureInput]);
-  const signatureKey = signature?.toString() ?? null;
-  const fetcher = react.useCallback(
-    async (client$1) => {
-      if (!signatureKey) {
-        throw new Error("Provide a signature before querying its status.");
-      }
-      if (!signature) {
-        throw new Error("Provide a signature before querying its status.");
-      }
-      const plan = client$1.runtime.rpc.getSignatureStatuses([signature], config);
-      const response = await plan.send({ abortSignal: AbortSignal.timeout(client.SIGNATURE_STATUS_TIMEOUT_MS) });
-      return response.value[0] ?? null;
-    },
-    [config, signature, signatureKey]
-  );
-  const disabled = disabledOption ?? !signatureKey;
-  const query = useSolanaRpcQuery(
-    "signatureStatus",
-    getSignatureStatusKey({ signature: signatureInput, config }),
-    fetcher,
-    {
-      disabled,
-      swr
-    }
-  );
-  const confirmationStatus = client.deriveConfirmationStatus(query.data ?? null);
-  return {
-    ...query,
-    confirmationStatus,
-    signatureStatus: query.data ?? null
-  };
-}
-__name(useSignatureStatus, "useSignatureStatus");
-function useWaitForSignature(signatureInput, options = {}) {
-  const {
-    commitment = "confirmed",
-    disabled: disabledOption,
-    subscribe = true,
-    watchCommitment,
-    ...signatureStatusOptions
-  } = options;
-  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,
-    swr: {
-      refreshInterval: 2e3,
-      ...swr
-    },
-    disabled
-  });
-  const [subscriptionSettled, setSubscriptionSettled] = react.useState(false);
-  react.useEffect(() => {
-    if (normalizedSignature === void 0) {
-      setSubscriptionSettled(false);
-      return;
-    }
-    setSubscriptionSettled(false);
-  }, [normalizedSignature]);
-  react.useEffect(() => {
-    if (!normalizedSignature || disabled || !subscribe) {
-      return;
-    }
-    const subscription = client$1.watchers.watchSignature(
-      {
-        commitment: subscribeCommitment,
-        enableReceivedNotification: true,
-        signature: normalizedSignature
-      },
-      () => {
-        setSubscriptionSettled(true);
-      }
-    );
-    return () => {
-      subscription.abort();
-    };
-  }, [client$1, disabled, normalizedSignature, subscribe, subscribeCommitment]);
-  const hasSignature = Boolean(normalizedSignature) && !disabled;
-  const signatureError = statusQuery.signatureStatus?.err ?? null;
-  const waitError = statusQuery.error ?? signatureError ?? null;
-  const meetsCommitment = client.confirmationMeetsCommitment(statusQuery.confirmationStatus, commitment);
-  const settled = subscriptionSettled || meetsCommitment;
-  let waitStatus = "idle";
-  if (!hasSignature) {
-    waitStatus = "idle";
-  } else if (waitError) {
-    waitStatus = "error";
-  } else if (settled) {
-    waitStatus = "success";
-  } else {
-    waitStatus = "waiting";
-  }
-  return {
-    ...statusQuery,
-    isError: waitStatus === "error",
-    isSuccess: waitStatus === "success",
-    isWaiting: waitStatus === "waiting",
-    waitError,
-    waitStatus
-  };
-}
-__name(useWaitForSignature, "useWaitForSignature");
-function useLookupTable(addressLike, options = {}) {
-  const addr = react.useMemo(() => addressLike ? client.toAddress(addressLike) : void 0, [addressLike]);
-  const key = addr?.toString() ?? null;
-  const fetcher = react.useCallback(
-    async (c) => {
-      if (!addr) throw new Error("Address required");
-      return c.actions.fetchLookupTable(addr, options.commitment);
-    },
-    [addr, options.commitment]
-  );
-  return useSolanaRpcQuery("lookupTable", [key, options.commitment], fetcher, {
-    disabled: !addr,
-    swr: options.swr
-  });
-}
-__name(useLookupTable, "useLookupTable");
-function useNonceAccount(addressLike, options = {}) {
-  const addr = react.useMemo(() => addressLike ? client.toAddress(addressLike) : void 0, [addressLike]);
-  const key = addr?.toString() ?? null;
-  const fetcher = react.useCallback(
-    async (c) => {
-      if (!addr) throw new Error("Address required");
-      return c.actions.fetchNonceAccount(addr, options.commitment);
-    },
-    [addr, options.commitment]
-  );
-  return useSolanaRpcQuery("nonceAccount", [key, options.commitment], fetcher, {
-    disabled: !addr,
-    swr: options.swr
-  });
-}
-__name(useNonceAccount, "useNonceAccount");
-var createCache = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Map(), "createCache");
-var DEFAULT_QUERY_CONFIG = Object.freeze({
-  dedupingInterval: 2e3,
-  focusThrottleInterval: 5e3,
-  provider: /* @__PURE__ */ __name(() => createCache(), "provider"),
-  revalidateIfStale: true,
-  revalidateOnFocus: true,
-  revalidateOnReconnect: true
-});
-function SolanaQueryProvider({
-  children,
-  config,
-  resetOnClusterChange = true,
-  suspense
-}) {
-  const cluster = useClientStore((state) => state.cluster);
-  const cacheRegistryRef = react.useRef(/* @__PURE__ */ new Map());
-  const cacheKey = resetOnClusterChange ? `${cluster.endpoint}|${cluster.commitment}` : "global";
-  const cache = react.useMemo(() => {
-    const registry = cacheRegistryRef.current;
-    if (!resetOnClusterChange) {
-      const existing = registry.get("global");
-      if (existing) {
-        return existing;
-      }
-      const next2 = createCache();
-      registry.set("global", next2);
-      return next2;
-    }
-    const next = createCache();
-    registry.set(cacheKey, next);
-    return next;
-  }, [cacheKey, resetOnClusterChange]);
-  const value = react.useMemo(() => {
-    const base = {
-      ...DEFAULT_QUERY_CONFIG,
-      ...config
-    };
-    if (!config?.provider) {
-      base.provider = () => cache;
-    }
-    if (base.suspense === void 0 && suspense !== void 0) {
-      base.suspense = suspense;
-    }
-    return base;
-  }, [cache, config, suspense]);
-  return /* @__PURE__ */ jsxRuntime.jsx(QuerySuspenseContext.Provider, { value: suspense, children: /* @__PURE__ */ jsxRuntime.jsx(useSWR.SWRConfig, { value, children }) });
-}
-__name(SolanaQueryProvider, "SolanaQueryProvider");
-function SolanaProvider({ children, client: client$1, 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 normalizedConfig = config ? client.resolveClientConfig(config) : client.resolveClientConfig();
-  const clientConfig = persistenceConfig ? { ...normalizedConfig, initialState: normalizedConfig.initialState ?? persistedState.state ?? void 0 } : normalizedConfig;
-  const content = shouldIncludeQueryLayer ? /* @__PURE__ */ jsxRuntime.jsx(
-    SolanaQueryProvider,
-    {
-      config: queryProps.config,
-      resetOnClusterChange: queryProps.resetOnClusterChange,
-      suspense: queryProps.suspense,
-      children
-    }
-  ) : children;
-  return /* @__PURE__ */ jsxRuntime.jsxs(SolanaClientProvider, { client: client$1, 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 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$1 = useSolanaClient();
-  const storageRef = react.useRef(storage ?? getDefaultStorage());
-  const [hasAttemptedAutoConnect, setHasAttemptedAutoConnect] = react.useState(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$1) {
-      clientRef.current = client$1;
-      setHasAttemptedAutoConnect(false);
-    }
-  }, [client$1]);
-  react.useEffect(() => {
-    const activeStorage = storageRef.current;
-    if (!activeStorage) return;
-    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(() => {
-    const persisted = persistedStateRef.current ?? initialState;
-    const persistedAutoConnect = persisted?.autoconnect ?? false;
-    const autoConnectEnabled = persistedAutoConnect || autoConnect;
-    if (!autoConnectEnabled || hasAttemptedAutoConnect) {
-      return;
-    }
-    if (wallet.status === "connected" || wallet.status === "connecting") {
-      setHasAttemptedAutoConnect(true);
-      return;
-    }
-    const connectorId = persisted?.lastConnectorId ?? legacyConnectorIdRef.current;
-    const shouldAutoConnect = autoConnectEnabled && connectorId;
-    if (!shouldAutoConnect || !connectorId) return;
-    const connector = client$1.connectors.get(connectorId);
-    if (!connector) return;
-    void (async () => {
-      try {
-        await connectWallet(connectorId, { autoConnect: true, allowInteractiveFallback: false });
-      } catch {
-      } finally {
-        setHasAttemptedAutoConnect(true);
-      }
-    })();
-  }, [autoConnect, client$1, connectWallet, hasAttemptedAutoConnect, initialState, wallet.status]);
-  return null;
-}
-__name(WalletPersistence, "WalletPersistence");
-function safelyRead(reader) {
-  try {
-    return reader();
-  } catch {
-    return null;
-  }
-}
-__name(safelyRead, "safelyRead");
-function safelyWrite(writer) {
-  try {
-    writer();
-  } catch {
-  }
-}
-__name(safelyWrite, "safelyWrite");
-function getDefaultStorage() {
-  if (typeof globalThis !== "object" || globalThis === null) {
-    return null;
-  }
-  const candidate = globalThis.localStorage;
-  if (!candidate) {
-    return null;
-  }
-  return candidate;
-}
-__name(getDefaultStorage, "getDefaultStorage");
-function useWalletConnection(options = {}) {
-  const wallet = useWallet();
-  const connectWallet = useConnectWallet();
-  const disconnectWallet = useDisconnectWallet();
-  const client = useSolanaClient();
-  const [isHydrated, setIsHydrated] = react.useState(false);
-  react.useEffect(() => {
-    setIsHydrated(true);
-  }, []);
-  const connectors = isHydrated ? options.connectors ?? client.connectors.all : [];
-  const connect = react.useCallback(
-    (connectorId, connectOptions) => connectWallet(connectorId, connectOptions),
-    [connectWallet]
-  );
-  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 {
-      connect,
-      connected: wallet.status === "connected",
-      connecting: wallet.status === "connecting",
-      connectors,
-      connectorId,
-      currentConnector,
-      disconnect,
-      error,
-      status: wallet.status,
-      wallet: session
-    };
-  }, [connect, connectors, disconnect, wallet]);
-  return state;
-}
-__name(useWalletConnection, "useWalletConnection");
-function WalletConnectionManager({ children, connectors }) {
-  const state = useWalletConnection({ connectors });
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children(state) });
-}
-__name(WalletConnectionManager, "WalletConnectionManager");
-function useWalletModalState(options = {}) {
-  const connection = useWalletConnection(options);
-  const [isOpen, setIsOpen] = react.useState(options.initialOpen ?? false);
-  const [selectedConnector, setSelectedConnector] = react.useState(null);
-  const closeOnConnect = options.closeOnConnect ?? true;
-  const open = react.useCallback(() => setIsOpen(true), []);
-  const close = react.useCallback(() => setIsOpen(false), []);
-  const toggle = react.useCallback(() => setIsOpen((value) => !value), []);
-  const select = react.useCallback((connectorId) => setSelectedConnector(connectorId), []);
-  const connect = react.useCallback(
-    async (connectorId, connectOptions) => {
-      await connection.connect(connectorId, connectOptions);
-      setSelectedConnector(connectorId);
-      if (closeOnConnect) {
-        setIsOpen(false);
-      }
-    },
-    [closeOnConnect, connection]
-  );
-  return {
-    ...connection,
-    close,
-    connect,
-    isOpen,
-    open,
-    selectedConnector,
-    select,
-    toggle
-  };
-}
-__name(useWalletModalState, "useWalletModalState");
-
-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;
-exports.useClusterState = useClusterState;
-exports.useClusterStatus = useClusterStatus;
-exports.useConnectWallet = useConnectWallet;
-exports.useDisconnectWallet = useDisconnectWallet;
-exports.useLatestBlockhash = useLatestBlockhash;
-exports.useLookupTable = useLookupTable;
-exports.useNonceAccount = useNonceAccount;
-exports.useProgramAccounts = useProgramAccounts;
-exports.useSendTransaction = useSendTransaction;
-exports.useSignatureStatus = useSignatureStatus;
-exports.useSimulateTransaction = useSimulateTransaction;
-exports.useSolTransfer = useSolTransfer;
-exports.useSolanaClient = useSolanaClient;
-exports.useSplToken = useSplToken;
-exports.useStake = useStake;
-exports.useTransactionPool = useTransactionPool;
-exports.useWaitForSignature = useWaitForSignature;
-exports.useWallet = useWallet;
-exports.useWalletActions = useWalletActions;
-exports.useWalletConnection = useWalletConnection;
-exports.useWalletModalState = useWalletModalState;
-exports.useWalletSession = useWalletSession;
-//# sourceMappingURL=index.browser.cjs.map
-//# sourceMappingURL=index.browser.cjs.map