@solana/react-hooks 0.0.2 → 0.1.0

package/dist/index.native.mjs

@@ -1,6 +1,6 @@
 import { createClient, toAddress, toAddressString, stableStringify, createSolTransferController, createSplTransferController, getWalletStandardConnectors, watchWalletStandardConnectors, createTransactionPoolController, createInitialAsyncState, createAsyncState, normalizeSignature, SIGNATURE_STATUS_TIMEOUT_MS, deriveConfirmationStatus, confirmationMeetsCommitment } from '@solana/client';
 import { createContext, useMemo, useEffect, useContext, useCallback, useRef, useSyncExternalStore, useState } from 'react';
-import { jsx } from 'react/jsx-runtime';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import useSWR, { SWRConfig } from 'swr';
 import { useStore } from 'zustand';
 import { getBase64EncodedWireTransaction } from '@solana/kit';
@@ -776,6 +776,191 @@ function SolanaQueryProvider({
   return /* @__PURE__ */ jsx(QuerySuspenseContext.Provider, { value: suspense, children: /* @__PURE__ */ jsx(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__ */ jsx(
+    SolanaQueryProvider,
+    {
+      config: queryProps.config,
+      resetOnClusterChange: queryProps.resetOnClusterChange,
+      suspense: queryProps.suspense,
+      children
+    }
+  ) : children;
+  return /* @__PURE__ */ jsxs(SolanaClientProvider, { client, config, children: [
+    persistenceConfig ? /* @__PURE__ */ 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 = useRef(storage ?? getDefaultStorage());
+  const [hasAttemptedAutoConnect, setHasAttemptedAutoConnect] = useState(false);
+  const hasPersistedConnectorRef = useRef(false);
+  const clientRef = useRef(null);
+  useEffect(() => {
+    storageRef.current = storage ?? getDefaultStorage();
+  }, [storage]);
+  useEffect(() => {
+    if (clientRef.current !== client) {
+      clientRef.current = client;
+      setHasAttemptedAutoConnect(false);
+    }
+  }, [client]);
+  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]);
+  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 = useCallback(
+    (connectorId, connectOptions) => connectWallet(connectorId, connectOptions),
+    [connectWallet]
+  );
+  const disconnect = useCallback(() => disconnectWallet(), [disconnectWallet]);
+  const state = 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__ */ jsx(Fragment, { children: children(state) });
+}
+__name(WalletConnectionManager, "WalletConnectionManager");
+function useWalletModalState(options = {}) {
+  const connection = useWalletConnection(options);
+  const [isOpen, setIsOpen] = useState(options.initialOpen ?? false);
+  const [selectedConnector, setSelectedConnector] = useState(null);
+  const closeOnConnect = options.closeOnConnect ?? true;
+  const open = useCallback(() => setIsOpen(true), []);
+  const close = useCallback(() => setIsOpen(false), []);
+  const toggle = useCallback(() => setIsOpen((value) => !value), []);
+  const select = useCallback((connectorId) => setSelectedConnector(connectorId), []);
+  const connect = 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 useCallback(
@@ -1104,6 +1289,6 @@ function useWalletAccountTransactionSendingSigner(uiWalletAccount, chain) {
 }
 __name(useWalletAccountTransactionSendingSigner, "useWalletAccountTransactionSendingSigner");
 
-export { SolanaClientProvider, SolanaQueryProvider, useAccount, useBalance, useClientStore, useClusterState, useClusterStatus, useConnectWallet, useDisconnectWallet, useLatestBlockhash, useProgramAccounts, useSendTransaction, useSignAndSendTransaction, useSignIn, useSignMessage, useSignTransaction, useSignatureStatus, useSimulateTransaction, useSolTransfer, useSolanaClient, useSplToken, useTransactionPool, useWaitForSignature, useWallet, useWalletAccountMessageSigner, useWalletAccountTransactionSendingSigner, useWalletAccountTransactionSigner, useWalletActions, useWalletSession, useWalletStandardConnectors };
+export { SolanaClientProvider, SolanaProvider, SolanaQueryProvider, WalletConnectionManager, useAccount, useBalance, useClientStore, useClusterState, useClusterStatus, useConnectWallet, useDisconnectWallet, useLatestBlockhash, useProgramAccounts, useSendTransaction, useSignAndSendTransaction, useSignIn, useSignMessage, useSignTransaction, useSignatureStatus, useSimulateTransaction, useSolTransfer, useSolanaClient, useSplToken, useTransactionPool, useWaitForSignature, useWallet, useWalletAccountMessageSigner, useWalletAccountTransactionSendingSigner, useWalletAccountTransactionSigner, useWalletActions, useWalletConnection, useWalletModalState, useWalletSession, useWalletStandardConnectors };
 //# sourceMappingURL=index.native.mjs.map
 //# sourceMappingURL=index.native.mjs.map