@solana/react-hooks 0.0.0 → 0.1.0

package/dist/index.node.cjs

@@ -0,0 +1,1333 @@
+'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');
+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 }; }
+
+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 SolanaClientProvider({ children, client: providedClient, config }) {
+  const client$1 = react.useMemo(() => {
+    if (providedClient) {
+      return providedClient;
+    }
+    if (!config) {
+      throw new Error("SolanaClientProvider requires either a `client` or `config` prop.");
+    }
+    return client.createClient(config);
+  }, [config, 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, ...restOptions } = options;
+  const providerSuspensePreference = useQuerySuspensePreference();
+  const suspenseEnabled = !disabled && Boolean(providerSuspensePreference);
+  const swrOptions = {
+    ...restOptions,
+    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 swr = useSWR__default.default(key, () => fetcher(client), swrOptions);
+  const [dataUpdatedAt, setDataUpdatedAt] = react.useState(
+    () => swr.data !== void 0 ? Date.now() : void 0
+  );
+  react.useEffect(() => {
+    if (swr.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]);
+  return {
+    data: swr.data,
+    dataUpdatedAt,
+    error: swr.error ?? null,
+    isError: status === "error",
+    isLoading: swr.isLoading,
+    isSuccess: status === "success",
+    isValidating: swr.isValidating,
+    mutate: swr.mutate,
+    refresh,
+    status
+  };
+}
+__name(useSolanaRpcQuery, "useSolanaRpcQuery");
+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]
+  );
+  const fetcher = react.useCallback(
+    async (client) => {
+      const fallbackCommitment = commitment ?? client.store.getState().cluster.commitment;
+      const plan = client.runtime.rpc.getLatestBlockhash({
+        commitment: fallbackCommitment,
+        minContextSlot: normalizedMinContextSlot
+      });
+      return plan.send({ abortSignal: AbortSignal.timeout(15e3) });
+    },
+    [commitment, normalizedMinContextSlot]
+  );
+  const query = useSolanaRpcQuery("latestBlockhash", keyArgs, fetcher, {
+    refreshInterval,
+    ...rest
+  });
+  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, ...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 fetcher = react.useCallback(
+    async (client) => {
+      if (!address2) {
+        throw new Error("Provide a program address before querying program accounts.");
+      }
+      const fallbackCommitment = commitment ?? config?.commitment ?? client.store.getState().cluster.commitment;
+      const mergedConfig = {
+        ...config ?? {},
+        commitment: fallbackCommitment
+      };
+      const plan = client.runtime.rpc.getProgramAccounts(address2, mergedConfig);
+      return plan.send({ abortSignal: AbortSignal.timeout(2e4) });
+    },
+    [address2, commitment, config]
+  );
+  const disabled = disabledOption ?? !address2;
+  const query = useSolanaRpcQuery("programAccounts", [addressKey, configKey], fetcher, {
+    ...restQueryOptions,
+    disabled
+  });
+  return {
+    ...query,
+    accounts: query.data ?? []
+  };
+}
+__name(useProgramAccounts, "useProgramAccounts");
+function useSimulateTransaction(transaction, options) {
+  const { commitment, config, refreshInterval, ...rest } = options ?? {};
+  const { disabled: disabledOption, revalidateIfStale, revalidateOnFocus, ...queryOptions } = rest;
+  const wire = react.useMemo(() => {
+    if (!transaction) {
+      return null;
+    }
+    if (typeof transaction === "string") {
+      return transaction;
+    }
+    return kit.getBase64EncodedWireTransaction(transaction);
+  }, [transaction]);
+  const configKey = react.useMemo(() => client.stableStringify(config ?? null), [config]);
+  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", [wire, configKey], fetcher, {
+    ...queryOptions,
+    refreshInterval,
+    disabled,
+    revalidateIfStale: revalidateIfStale ?? false,
+    revalidateOnFocus: revalidateOnFocus ?? false
+  });
+  return {
+    ...query,
+    logs: query.data?.value.logs ?? []
+  };
+}
+__name(useSimulateTransaction, "useSimulateTransaction");
+
+// 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 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 useSplToken(mint, options = {}) {
+  const client$1 = useSolanaClient();
+  const session = useWalletSession();
+  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 { data, error, isLoading, isValidating, mutate } = useSWR__default.default(balanceKey, fetchBalance, {
+    revalidateOnFocus: options.revalidateOnFocus ?? false
+  });
+  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 address2 = react.useMemo(() => {
+    if (shouldSkip || !addressLike) {
+      return void 0;
+    }
+    return client.toAddress(addressLike);
+  }, [addressLike, shouldSkip]);
+  const accountKey = react.useMemo(() => address2?.toString(), [address2]);
+  const selector = react.useMemo(() => createAccountSelector(accountKey), [accountKey]);
+  const account = useClientStore(selector);
+  react.useEffect(() => {
+    if (!address2) {
+      return;
+    }
+    const commitment = options.commitment;
+    if (options.fetch !== false) {
+      void client$1.actions.fetchAccount(address2, commitment).catch(() => void 0);
+    }
+    if (options.watch) {
+      const subscription = client$1.watchers.watchAccount({ address: address2, commitment }, () => void 0);
+      return () => {
+        subscription.abort();
+      };
+    }
+    return void 0;
+  }, [address2, 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 address2 = react.useMemo(() => {
+    if (shouldSkip || !addressLike) {
+      return void 0;
+    }
+    return client.toAddress(addressLike);
+  }, [addressLike, shouldSkip]);
+  const accountKey = react.useMemo(() => address2?.toString(), [address2]);
+  const selector = react.useMemo(() => createAccountSelector(accountKey), [accountKey]);
+  const account = useClientStore(selector);
+  react.useEffect(() => {
+    if (!address2) {
+      return;
+    }
+    const commitment = mergedOptions.commitment;
+    if (mergedOptions.fetch !== false) {
+      void client$1.actions.fetchBalance(address2, commitment).catch(() => void 0);
+    }
+    if (mergedOptions.watch) {
+      const watcher = client$1.watchers.watchBalance({ address: address2, commitment }, () => void 0);
+      return () => {
+        watcher.abort();
+      };
+    }
+    return void 0;
+  }, [address2, 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 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 ?? [],
+    [config.instructions]
+  );
+  const client$1 = useSolanaClient();
+  const helper = client$1.helpers.transaction;
+  const blockhashMaxAgeMs = config.latestBlockhash?.refreshInterval ?? 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, ...queryOptions } = 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) {
+        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 = queryOptions.disabled ?? !signatureKey;
+  const query = useSolanaRpcQuery(
+    "signatureStatus",
+    [signatureKey, configKey],
+    fetcher,
+    {
+      ...queryOptions,
+      disabled
+    }
+  );
+  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 { refreshInterval, ...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,
+    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");
+var createCache = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Map(), "createCache");
+var DEFAULT_QUERY_CONFIG = Object.freeze({
+  dedupingInterval: 1e3,
+  focusThrottleInterval: 1e3,
+  provider: /* @__PURE__ */ __name(() => createCache(), "provider"),
+  revalidateOnFocus: false,
+  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, config, query, walletPersistence }) {
+  const shouldIncludeQueryLayer = query !== false && query?.disabled !== true;
+  const queryProps = shouldIncludeQueryLayer && query ? query : {};
+  const persistenceConfig = walletPersistence === false ? void 0 : walletPersistence ?? {};
+  const content = shouldIncludeQueryLayer ? /* @__PURE__ */ jsxRuntime.jsx(
+    SolanaQueryProvider,
+    {
+      config: queryProps.config,
+      resetOnClusterChange: queryProps.resetOnClusterChange,
+      suspense: queryProps.suspense,
+      children
+    }
+  ) : children;
+  return /* @__PURE__ */ jsxRuntime.jsxs(SolanaClientProvider, { client, config, children: [
+    persistenceConfig ? /* @__PURE__ */ jsxRuntime.jsx(WalletPersistence, { ...persistenceConfig }) : null,
+    content
+  ] });
+}
+__name(SolanaProvider, "SolanaProvider");
+var DEFAULT_STORAGE_KEY = "solana:last-connector";
+function WalletPersistence({ autoConnect = true, storage, storageKey = DEFAULT_STORAGE_KEY }) {
+  const wallet = useWallet();
+  const connectWallet = useConnectWallet();
+  const client = useSolanaClient();
+  const storageRef = react.useRef(storage ?? getDefaultStorage());
+  const [hasAttemptedAutoConnect, setHasAttemptedAutoConnect] = react.useState(false);
+  const hasPersistedConnectorRef = react.useRef(false);
+  const clientRef = react.useRef(null);
+  react.useEffect(() => {
+    storageRef.current = storage ?? getDefaultStorage();
+  }, [storage]);
+  react.useEffect(() => {
+    if (clientRef.current !== client) {
+      clientRef.current = client;
+      setHasAttemptedAutoConnect(false);
+    }
+  }, [client]);
+  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]);
+  react.useEffect(() => {
+    if (!autoConnect || hasAttemptedAutoConnect) {
+      return;
+    }
+    if (wallet.status === "connected" || wallet.status === "connecting") {
+      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;
+    }
+    void (async () => {
+      try {
+        await connectWallet(connectorId, { autoConnect: true });
+      } catch {
+      } finally {
+        if (!cancelled) {
+          setHasAttemptedAutoConnect(true);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [autoConnect, client, connectWallet, hasAttemptedAutoConnect, storageKey, 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 discovered = useWalletStandardConnectors(options.discoveryOptions);
+  const connectors = options.connectors ?? discovered;
+  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 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,
+      disconnect,
+      error,
+      status: wallet.status,
+      wallet: session
+    };
+  }, [connect, connectors, disconnect, wallet]);
+  return state;
+}
+__name(useWalletConnection, "useWalletConnection");
+function WalletConnectionManager({ children, connectors, discoveryOptions }) {
+  const state = useWalletConnection({ connectors, discoveryOptions });
+  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");
+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.useAccount = useAccount;
+exports.useBalance = useBalance;
+exports.useClientStore = useClientStore;
+exports.useClusterState = useClusterState;
+exports.useClusterStatus = useClusterStatus;
+exports.useConnectWallet = useConnectWallet;
+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;
+exports.useSolanaClient = useSolanaClient;
+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.node.cjs.map
+//# sourceMappingURL=index.node.cjs.map