@phantom/react-sdk 0.3.9 → 1.0.0-beta.1

package/dist/index.mjs

@@ -4,14 +4,6 @@ import { BrowserSDK } from "@phantom/browser-sdk";
 import { jsx } from "react/jsx-runtime";
 var PhantomContext = createContext(void 0);
 function PhantomProvider({ children, config, debugConfig }) {
-  const [isConnected, setIsConnected] = useState(false);
-  const [isConnecting, setIsConnecting] = useState(false);
-  const [connectError, setConnectError] = useState(null);
-  const [addresses, setAddresses] = useState([]);
-  const [walletId, setWalletId] = useState(null);
-  const [currentProviderType, setCurrentProviderType] = useState(config.providerType || null);
-  const [isPhantomAvailable, setIsPhantomAvailable] = useState(false);
-  const [sdk, setSdk] = useState(null);
   const memoizedConfig = useMemo(() => {
     return {
       ...config,
@@ -19,6 +11,16 @@ function PhantomProvider({ children, config, debugConfig }) {
       providerType: config.providerType || "embedded"
     };
   }, [config]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [isConnecting, setIsConnecting] = useState(false);
+  const [connectError, setConnectError] = useState(null);
+  const [addresses, setAddresses] = useState([]);
+  const [walletId, setWalletId] = useState(null);
+  const [currentProviderType, setCurrentProviderType] = useState(
+    memoizedConfig.providerType || null
+  );
+  const [isPhantomAvailable, setIsPhantomAvailable] = useState(false);
+  const [sdk, setSdk] = useState(null);
   useEffect(() => {
     const sdkInstance = new BrowserSDK(memoizedConfig);
     const handleConnectStart = () => {
@@ -77,19 +79,19 @@ function PhantomProvider({ children, config, debugConfig }) {
       return;
     const initialize = async () => {
       try {
-        const available = await sdk.waitForPhantomExtension(1e3);
+        const available = await BrowserSDK.isPhantomInstalled();
         setIsPhantomAvailable(available);
       } catch (err) {
         console.error("Error checking Phantom extension:", err);
         setIsPhantomAvailable(false);
       }
-      if (config.autoConnect !== false) {
+      if (memoizedConfig.autoConnect !== false) {
         sdk.autoConnect().catch(() => {
         });
       }
     };
     initialize();
-  }, [sdk, config.autoConnect]);
+  }, [sdk, memoizedConfig.autoConnect]);
   const value = useMemo(
     () => ({
       sdk,
@@ -101,16 +103,7 @@ function PhantomProvider({ children, config, debugConfig }) {
       currentProviderType,
       isPhantomAvailable
     }),
-    [
-      sdk,
-      isConnected,
-      isConnecting,
-      connectError,
-      addresses,
-      walletId,
-      currentProviderType,
-      isPhantomAvailable
-    ]
+    [sdk, isConnected, isConnecting, connectError, addresses, walletId, currentProviderType, isPhantomAvailable]
   );
   return /* @__PURE__ */ jsx(PhantomContext.Provider, { value, children });
 }
@@ -178,115 +171,311 @@ function useDisconnect() {
   };
 }
 
-// src/hooks/useSignMessage.ts
-import { useCallback as useCallback3, useState as useState3 } from "react";
-function useSignMessage() {
-  const { sdk } = usePhantom();
-  const [isSigning, setIsSigning] = useState3(false);
-  const [error, setError] = useState3(null);
-  const signMessage = useCallback3(
-    async (params) => {
-      if (!sdk) {
-        throw new Error("SDK not initialized");
-      }
-      if (!sdk.isConnected()) {
-        throw new Error("Wallet not connected");
-      }
-      setIsSigning(true);
-      setError(null);
+// src/hooks/useAccounts.ts
+function useAccounts() {
+  const { addresses, isConnected } = usePhantom();
+  return isConnected ? addresses : null;
+}
+
+// src/hooks/useIsExtensionInstalled.ts
+import * as React from "react";
+import { waitForPhantomExtension } from "@phantom/browser-sdk";
+function useIsExtensionInstalled() {
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [isInstalled, setIsInstalled] = React.useState(false);
+  React.useEffect(() => {
+    let isMounted = true;
+    const checkExtension = async () => {
       try {
-        const signature = await sdk.signMessage(params);
-        return signature;
-      } catch (err) {
-        setError(err);
-        throw err;
+        setIsLoading(true);
+        const result = await waitForPhantomExtension(3e3);
+        if (isMounted) {
+          setIsInstalled(result);
+        }
+      } catch (error) {
+        if (isMounted) {
+          setIsInstalled(false);
+        }
       } finally {
-        setIsSigning(false);
+        if (isMounted) {
+          setIsLoading(false);
+        }
       }
-    },
-    [sdk]
-  );
-  return {
-    signMessage,
-    isSigning,
-    error
-  };
+    };
+    checkExtension();
+    return () => {
+      isMounted = false;
+    };
+  }, []);
+  return { isLoading, isInstalled };
 }
 
-// src/hooks/useSignAndSendTransaction.ts
-import { useCallback as useCallback4, useState as useState4 } from "react";
-function useSignAndSendTransaction() {
-  const { sdk } = usePhantom();
-  const [isSigning, setIsSigning] = useState4(false);
+// src/hooks/useAutoConfirm.ts
+import { useCallback as useCallback3, useState as useState4, useEffect as useEffect3 } from "react";
+function useAutoConfirm() {
+  const { sdk, currentProviderType } = usePhantom();
+  const [status, setStatus] = useState4(null);
+  const [supportedChains, setSupportedChains] = useState4(null);
+  const [isLoading, setIsLoading] = useState4(false);
   const [error, setError] = useState4(null);
-  const signAndSendTransaction = useCallback4(
+  const isInjected = currentProviderType === "injected";
+  const enable = useCallback3(
     async (params) => {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      if (!sdk.isConnected()) {
-        throw new Error("Wallet not connected");
+      if (!isInjected) {
+        throw new Error("Auto-confirm is only available for injected (extension) providers");
       }
-      setIsSigning(true);
-      setError(null);
       try {
-        const result = await sdk.signAndSendTransaction(params);
+        setIsLoading(true);
+        setError(null);
+        const result = await sdk.enableAutoConfirm(params);
+        setStatus(result);
         return result;
       } catch (err) {
-        setError(err);
-        throw err;
+        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error2);
+        throw error2;
       } finally {
-        setIsSigning(false);
+        setIsLoading(false);
       }
     },
-    [sdk]
+    [sdk, isInjected]
   );
+  const disable = useCallback3(async () => {
+    if (!sdk) {
+      throw new Error("SDK not initialized");
+    }
+    if (!isInjected) {
+      throw new Error("Auto-confirm is only available for injected (extension) providers");
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      await sdk.disableAutoConfirm();
+      const newStatus = await sdk.getAutoConfirmStatus();
+      setStatus(newStatus);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, isInjected]);
+  const refetch = useCallback3(async () => {
+    if (!sdk || !isInjected) {
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const [statusResult, supportedResult] = await Promise.all([
+        sdk.getAutoConfirmStatus(),
+        sdk.getSupportedAutoConfirmChains()
+      ]);
+      setStatus(statusResult);
+      setSupportedChains(supportedResult);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch auto-confirm data");
+      setError(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, isInjected]);
+  useEffect3(() => {
+    if (sdk && isInjected) {
+      refetch();
+    } else {
+      setStatus(null);
+      setSupportedChains(null);
+      setError(null);
+    }
+  }, [sdk, isInjected, refetch]);
   return {
-    signAndSendTransaction,
-    isSigning,
-    error
+    enable,
+    disable,
+    status,
+    supportedChains,
+    isLoading,
+    error,
+    refetch
   };
 }
 
-// src/hooks/useAccounts.ts
-function useAccounts() {
-  const { addresses, isConnected } = usePhantom();
-  return isConnected ? addresses : null;
+// src/hooks/useSolana.ts
+import { useCallback as useCallback4, useMemo as useMemo2 } from "react";
+function useSolana() {
+  const { sdk, isConnected } = usePhantom();
+  const solanaChain = useMemo2(() => {
+    if (!sdk || !isConnected)
+      return null;
+    try {
+      return sdk.solana;
+    } catch {
+      return null;
+    }
+  }, [sdk, isConnected]);
+  const signMessage = useCallback4(
+    async (message) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signMessage(message);
+    },
+    [solanaChain]
+  );
+  const signTransaction = useCallback4(
+    async (transaction) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signTransaction(transaction);
+    },
+    [solanaChain]
+  );
+  const signAndSendTransaction = useCallback4(
+    async (transaction) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signAndSendTransaction(transaction);
+    },
+    [solanaChain]
+  );
+  const connect = useCallback4(
+    async (options) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.connect(options);
+    },
+    [solanaChain]
+  );
+  const disconnect = useCallback4(async () => {
+    if (!solanaChain)
+      throw new Error("Solana chain not available. Ensure SDK is connected.");
+    return solanaChain.disconnect();
+  }, [solanaChain]);
+  const switchNetwork = useCallback4(
+    async (network) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.switchNetwork?.(network);
+    },
+    [solanaChain]
+  );
+  const getPublicKey = useCallback4(async () => {
+    if (!solanaChain)
+      return null;
+    return solanaChain.getPublicKey();
+  }, [solanaChain]);
+  return {
+    // Chain instance for advanced usage
+    solana: solanaChain,
+    // Convenient methods
+    signMessage,
+    signTransaction,
+    signAndSendTransaction,
+    connect,
+    disconnect,
+    switchNetwork,
+    getPublicKey,
+    // State
+    isAvailable: !!solanaChain,
+    isConnected: solanaChain?.isConnected() ?? false
+  };
 }
 
-// src/hooks/useIsExtensionInstalled.ts
-import * as React from "react";
-var cachedIsInstalled = null;
-function useIsExtensionInstalled() {
-  const { sdk } = usePhantom();
-  const [isLoading, setIsLoading] = React.useState(cachedIsInstalled === null);
-  const [isInstalled, setIsInstalled] = React.useState(cachedIsInstalled ?? false);
-  React.useEffect(() => {
-    if (!sdk) {
-      setIsLoading(false);
-      return;
-    }
-    if (cachedIsInstalled !== null) {
-      setIsInstalled(cachedIsInstalled);
-      setIsLoading(false);
-      return;
+// src/hooks/useEthereum.ts
+import { useCallback as useCallback5, useMemo as useMemo3 } from "react";
+function useEthereum() {
+  const { sdk, isConnected } = usePhantom();
+  const ethereumChain = useMemo3(() => {
+    if (!sdk || !isConnected)
+      return null;
+    try {
+      return sdk.ethereum;
+    } catch {
+      return null;
     }
-    const checkExtension = async () => {
-      try {
-        setIsLoading(true);
-        const result = await sdk.waitForPhantomExtension(1e3);
-        cachedIsInstalled = result;
-        setIsInstalled(result);
-      } catch (error) {
-        cachedIsInstalled = false;
-        setIsInstalled(false);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-    checkExtension();
-  }, [sdk]);
-  return { isLoading, isInstalled };
+  }, [sdk, isConnected]);
+  const request = useCallback5(
+    async (args) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.request(args);
+    },
+    [ethereumChain]
+  );
+  const signPersonalMessage = useCallback5(
+    async (message, address) => {
+      return request({
+        method: "personal_sign",
+        params: [message, address]
+      });
+    },
+    [request]
+  );
+  const sendTransaction = useCallback5(
+    async (transaction) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.sendTransaction(transaction);
+    },
+    [ethereumChain]
+  );
+  const switchChain = useCallback5(
+    async (chainId) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.switchChain(chainId);
+    },
+    [ethereumChain]
+  );
+  const getChainId = useCallback5(async () => {
+    if (!ethereumChain)
+      throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+    return ethereumChain.getChainId();
+  }, [ethereumChain]);
+  const getAccounts = useCallback5(async () => {
+    if (!ethereumChain)
+      throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+    return ethereumChain.getAccounts();
+  }, [ethereumChain]);
+  const signMessage = useCallback5(
+    async (message) => {
+      return request({
+        method: "eth_sign",
+        params: [await getAccounts().then((accounts) => accounts[0]), message]
+      });
+    },
+    [request, getAccounts]
+  );
+  const signTypedData = useCallback5(
+    async (typedData) => {
+      const accounts = await getAccounts();
+      return request({
+        method: "eth_signTypedData_v4",
+        params: [accounts[0], JSON.stringify(typedData)]
+      });
+    },
+    [request, getAccounts]
+  );
+  return {
+    // Chain instance for advanced usage
+    ethereum: ethereumChain,
+    // Standard EIP-1193 interface
+    request,
+    // Convenient methods
+    signPersonalMessage,
+    signMessage,
+    signTypedData,
+    sendTransaction,
+    switchChain,
+    getChainId,
+    getAccounts,
+    // State
+    isAvailable: !!ethereumChain,
+    isConnected: ethereumChain?.isConnected() ?? false
+  };
 }
 
 // src/index.ts
@@ -298,10 +487,11 @@ export {
   PhantomProvider,
   debug,
   useAccounts,
+  useAutoConfirm,
   useConnect,
   useDisconnect,
+  useEthereum,
   useIsExtensionInstalled,
   usePhantom,
-  useSignAndSendTransaction,
-  useSignMessage
+  useSolana
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/react-sdk",
-  "version": "0.3.9",
+  "version": "1.0.0-beta.1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -26,7 +26,9 @@
     "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
   },
   "dependencies": {
-    "@phantom/browser-sdk": "^0.3.9"
+    "@phantom/browser-sdk": "^1.0.0-beta.1",
+    "@phantom/chains": "^1.0.0-beta.1",
+    "@phantom/constants": "^1.0.0-beta.1"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.0",