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

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { BrowserSDKConfig, DebugConfig, AuthOptions, BrowserSDK, WalletAddress, SignMessageParams, SignMessageResult, SignAndSendTransactionParams, SignedTransaction } from '@phantom/browser-sdk';
-export { AddressType, DebugLevel, DebugMessage, NetworkId, SignAndSendTransactionParams, SignMessageParams, SignMessageResult, SignedTransaction, WalletAddress, debug } from '@phantom/browser-sdk';
+import { BrowserSDKConfig, DebugConfig, AuthOptions, BrowserSDK, WalletAddress, AutoConfirmEnableParams, AutoConfirmResult, AutoConfirmSupportedChainsResult } from '@phantom/browser-sdk';
+export { AddressType, AutoConfirmEnableParams, AutoConfirmResult, AutoConfirmSupportedChainsResult, DebugLevel, DebugMessage, NetworkId, SignedTransaction, WalletAddress, debug } from '@phantom/browser-sdk';
 import * as _phantom_embedded_provider_core from '@phantom/embedded-provider-core';
+import { ISolanaChain, IEthereumChain, EthTransactionRequest } from '@phantom/chains';
+export { EthTransactionRequest, IEthereumChain, ISolanaChain } from '@phantom/chains';
 
 interface PhantomSDKConfig extends BrowserSDKConfig {
 }
@@ -32,7 +34,7 @@ declare function PhantomProvider({ children, config, debugConfig }: PhantomProvi
 declare function usePhantom(): PhantomContextValue;
 
 declare function useConnect(): {
-    connect: (options?: ConnectOptions) => Promise<_phantom_embedded_provider_core.ConnectResult>;
+    connect: (options?: AuthOptions) => Promise<_phantom_embedded_provider_core.ConnectResult>;
     isConnecting: boolean;
     error: Error | null;
     currentProviderType: "injected" | "embedded" | null;
@@ -45,25 +47,77 @@ declare function useDisconnect(): {
     error: Error | null;
 };
 
-declare function useSignMessage(): {
-    signMessage: (params: SignMessageParams) => Promise<SignMessageResult>;
-    isSigning: boolean;
-    error: Error | null;
-};
-
-declare function useSignAndSendTransaction(): {
-    signAndSendTransaction: (params: SignAndSendTransactionParams) => Promise<SignedTransaction>;
-    isSigning: boolean;
-    error: Error | null;
-};
-
 declare function useAccounts(): _phantom_embedded_provider_core.WalletAddress[] | null;
 
+/**
+ * React hook to check if Phantom extension is installed
+ * Uses waitForPhantomExtension for proper detection with retry logic
+ */
 declare function useIsExtensionInstalled(): {
     isLoading: boolean;
     isInstalled: boolean;
 };
 
+interface UseAutoConfirmResult {
+    enable: (params: AutoConfirmEnableParams) => Promise<AutoConfirmResult>;
+    disable: () => Promise<void>;
+    status: AutoConfirmResult | null;
+    supportedChains: AutoConfirmSupportedChainsResult | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+declare function useAutoConfirm(): UseAutoConfirmResult;
+
+/**
+ * Hook for Solana chain operations
+ *
+ * @returns Solana chain interface and convenient methods
+ */
+declare function useSolana(): {
+    solana: ISolanaChain | null;
+    signMessage: (message: string | Uint8Array) => Promise<{
+        signature: Uint8Array;
+        publicKey: string;
+    }>;
+    signTransaction: <T>(transaction: T) => Promise<T>;
+    signAndSendTransaction: <T>(transaction: T) => Promise<{
+        signature: string;
+    }>;
+    connect: (options?: {
+        onlyIfTrusted?: boolean;
+    }) => Promise<{
+        publicKey: string;
+    }>;
+    disconnect: () => Promise<void>;
+    switchNetwork: (network: "mainnet" | "devnet") => Promise<void | undefined>;
+    getPublicKey: () => Promise<string | null>;
+    isAvailable: boolean;
+    isConnected: boolean;
+};
+
+/**
+ * Hook for Ethereum chain operations
+ *
+ * @returns Ethereum chain interface and convenient methods
+ */
+declare function useEthereum(): {
+    ethereum: IEthereumChain | null;
+    request: <T = any>(args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<T>;
+    signPersonalMessage: (message: string, address: string) => Promise<string>;
+    signMessage: (message: string) => Promise<string>;
+    signTypedData: (typedData: any) => Promise<string>;
+    sendTransaction: (transaction: EthTransactionRequest) => Promise<string>;
+    switchChain: (chainId: number) => Promise<void>;
+    getChainId: () => Promise<number>;
+    getAccounts: () => Promise<string[]>;
+    isAvailable: boolean;
+    isConnected: boolean;
+};
+
 type ProviderType = "injected" | "embedded";
 
-export { ConnectOptions, PhantomDebugConfig, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, ProviderType, useAccounts, useConnect, useDisconnect, useIsExtensionInstalled, usePhantom, useSignAndSendTransaction, useSignMessage };
+export { ConnectOptions, PhantomDebugConfig, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, ProviderType, useAccounts, useAutoConfirm, useConnect, useDisconnect, useEthereum, useIsExtensionInstalled, usePhantom, useSolana };

package/dist/index.js

@@ -30,18 +30,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AddressType: () => import_browser_sdk2.AddressType,
-  DebugLevel: () => import_browser_sdk2.DebugLevel,
-  NetworkId: () => import_browser_sdk2.NetworkId,
+  AddressType: () => import_browser_sdk3.AddressType,
+  DebugLevel: () => import_browser_sdk3.DebugLevel,
+  NetworkId: () => import_browser_sdk3.NetworkId,
   PhantomProvider: () => PhantomProvider,
-  debug: () => import_browser_sdk2.debug,
+  debug: () => import_browser_sdk3.debug,
   useAccounts: () => useAccounts,
+  useAutoConfirm: () => useAutoConfirm,
   useConnect: () => useConnect,
   useDisconnect: () => useDisconnect,
+  useEthereum: () => useEthereum,
   useIsExtensionInstalled: () => useIsExtensionInstalled,
   usePhantom: () => usePhantom,
-  useSignAndSendTransaction: () => useSignAndSendTransaction,
-  useSignMessage: () => useSignMessage
+  useSolana: () => useSolana
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -51,14 +52,6 @@ var import_browser_sdk = require("@phantom/browser-sdk");
 var import_jsx_runtime = require("react/jsx-runtime");
 var PhantomContext = (0, import_react.createContext)(void 0);
 function PhantomProvider({ children, config, debugConfig }) {
-  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
-  const [isConnecting, setIsConnecting] = (0, import_react.useState)(false);
-  const [connectError, setConnectError] = (0, import_react.useState)(null);
-  const [addresses, setAddresses] = (0, import_react.useState)([]);
-  const [walletId, setWalletId] = (0, import_react.useState)(null);
-  const [currentProviderType, setCurrentProviderType] = (0, import_react.useState)(config.providerType || null);
-  const [isPhantomAvailable, setIsPhantomAvailable] = (0, import_react.useState)(false);
-  const [sdk, setSdk] = (0, import_react.useState)(null);
   const memoizedConfig = (0, import_react.useMemo)(() => {
     return {
       ...config,
@@ -66,6 +59,16 @@ function PhantomProvider({ children, config, debugConfig }) {
       providerType: config.providerType || "embedded"
     };
   }, [config]);
+  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
+  const [isConnecting, setIsConnecting] = (0, import_react.useState)(false);
+  const [connectError, setConnectError] = (0, import_react.useState)(null);
+  const [addresses, setAddresses] = (0, import_react.useState)([]);
+  const [walletId, setWalletId] = (0, import_react.useState)(null);
+  const [currentProviderType, setCurrentProviderType] = (0, import_react.useState)(
+    memoizedConfig.providerType || null
+  );
+  const [isPhantomAvailable, setIsPhantomAvailable] = (0, import_react.useState)(false);
+  const [sdk, setSdk] = (0, import_react.useState)(null);
   (0, import_react.useEffect)(() => {
     const sdkInstance = new import_browser_sdk.BrowserSDK(memoizedConfig);
     const handleConnectStart = () => {
@@ -124,19 +127,19 @@ function PhantomProvider({ children, config, debugConfig }) {
       return;
     const initialize = async () => {
       try {
-        const available = await sdk.waitForPhantomExtension(1e3);
+        const available = await import_browser_sdk.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 = (0, import_react.useMemo)(
     () => ({
       sdk,
@@ -148,16 +151,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__ */ (0, import_jsx_runtime.jsx)(PhantomContext.Provider, { value, children });
 }
@@ -225,116 +219,312 @@ function useDisconnect() {
   };
 }
 
-// src/hooks/useSignMessage.ts
+// src/hooks/useAccounts.ts
+function useAccounts() {
+  const { addresses, isConnected } = usePhantom();
+  return isConnected ? addresses : null;
+}
+
+// src/hooks/useIsExtensionInstalled.ts
+var React = __toESM(require("react"));
+var import_browser_sdk2 = require("@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 {
+        setIsLoading(true);
+        const result = await (0, import_browser_sdk2.waitForPhantomExtension)(3e3);
+        if (isMounted) {
+          setIsInstalled(result);
+        }
+      } catch (error) {
+        if (isMounted) {
+          setIsInstalled(false);
+        }
+      } finally {
+        if (isMounted) {
+          setIsLoading(false);
+        }
+      }
+    };
+    checkExtension();
+    return () => {
+      isMounted = false;
+    };
+  }, []);
+  return { isLoading, isInstalled };
+}
+
+// src/hooks/useAutoConfirm.ts
 var import_react4 = require("react");
-function useSignMessage() {
-  const { sdk } = usePhantom();
-  const [isSigning, setIsSigning] = (0, import_react4.useState)(false);
+function useAutoConfirm() {
+  const { sdk, currentProviderType } = usePhantom();
+  const [status, setStatus] = (0, import_react4.useState)(null);
+  const [supportedChains, setSupportedChains] = (0, import_react4.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
   const [error, setError] = (0, import_react4.useState)(null);
-  const signMessage = (0, import_react4.useCallback)(
+  const isInjected = currentProviderType === "injected";
+  const enable = (0, import_react4.useCallback)(
     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 signature = await sdk.signMessage(params);
-        return signature;
+        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 = (0, import_react4.useCallback)(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 = (0, import_react4.useCallback)(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]);
+  (0, import_react4.useEffect)(() => {
+    if (sdk && isInjected) {
+      refetch();
+    } else {
+      setStatus(null);
+      setSupportedChains(null);
+      setError(null);
+    }
+  }, [sdk, isInjected, refetch]);
   return {
-    signMessage,
-    isSigning,
-    error
+    enable,
+    disable,
+    status,
+    supportedChains,
+    isLoading,
+    error,
+    refetch
   };
 }
 
-// src/hooks/useSignAndSendTransaction.ts
+// src/hooks/useSolana.ts
 var import_react5 = require("react");
-function useSignAndSendTransaction() {
-  const { sdk } = usePhantom();
-  const [isSigning, setIsSigning] = (0, import_react5.useState)(false);
-  const [error, setError] = (0, import_react5.useState)(null);
+function useSolana() {
+  const { sdk, isConnected } = usePhantom();
+  const solanaChain = (0, import_react5.useMemo)(() => {
+    if (!sdk || !isConnected)
+      return null;
+    try {
+      return sdk.solana;
+    } catch {
+      return null;
+    }
+  }, [sdk, isConnected]);
+  const signMessage = (0, import_react5.useCallback)(
+    async (message) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signMessage(message);
+    },
+    [solanaChain]
+  );
+  const signTransaction = (0, import_react5.useCallback)(
+    async (transaction) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signTransaction(transaction);
+    },
+    [solanaChain]
+  );
   const signAndSendTransaction = (0, import_react5.useCallback)(
-    async (params) => {
-      if (!sdk) {
-        throw new Error("SDK not initialized");
-      }
-      if (!sdk.isConnected()) {
-        throw new Error("Wallet not connected");
-      }
-      setIsSigning(true);
-      setError(null);
-      try {
-        const result = await sdk.signAndSendTransaction(params);
-        return result;
-      } catch (err) {
-        setError(err);
-        throw err;
-      } finally {
-        setIsSigning(false);
-      }
+    async (transaction) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.signAndSendTransaction(transaction);
     },
-    [sdk]
+    [solanaChain]
+  );
+  const connect = (0, import_react5.useCallback)(
+    async (options) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.connect(options);
+    },
+    [solanaChain]
+  );
+  const disconnect = (0, import_react5.useCallback)(async () => {
+    if (!solanaChain)
+      throw new Error("Solana chain not available. Ensure SDK is connected.");
+    return solanaChain.disconnect();
+  }, [solanaChain]);
+  const switchNetwork = (0, import_react5.useCallback)(
+    async (network) => {
+      if (!solanaChain)
+        throw new Error("Solana chain not available. Ensure SDK is connected.");
+      return solanaChain.switchNetwork?.(network);
+    },
+    [solanaChain]
   );
+  const getPublicKey = (0, import_react5.useCallback)(async () => {
+    if (!solanaChain)
+      return null;
+    return solanaChain.getPublicKey();
+  }, [solanaChain]);
   return {
+    // Chain instance for advanced usage
+    solana: solanaChain,
+    // Convenient methods
+    signMessage,
+    signTransaction,
     signAndSendTransaction,
-    isSigning,
-    error
+    connect,
+    disconnect,
+    switchNetwork,
+    getPublicKey,
+    // State
+    isAvailable: !!solanaChain,
+    isConnected: solanaChain?.isConnected() ?? false
   };
 }
 
-// src/hooks/useAccounts.ts
-function useAccounts() {
-  const { addresses, isConnected } = usePhantom();
-  return isConnected ? addresses : null;
-}
-
-// src/hooks/useIsExtensionInstalled.ts
-var React = __toESM(require("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
+var import_react6 = require("react");
+function useEthereum() {
+  const { sdk, isConnected } = usePhantom();
+  const ethereumChain = (0, import_react6.useMemo)(() => {
+    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 = (0, import_react6.useCallback)(
+    async (args) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.request(args);
+    },
+    [ethereumChain]
+  );
+  const signPersonalMessage = (0, import_react6.useCallback)(
+    async (message, address) => {
+      return request({
+        method: "personal_sign",
+        params: [message, address]
+      });
+    },
+    [request]
+  );
+  const sendTransaction = (0, import_react6.useCallback)(
+    async (transaction) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.sendTransaction(transaction);
+    },
+    [ethereumChain]
+  );
+  const switchChain = (0, import_react6.useCallback)(
+    async (chainId) => {
+      if (!ethereumChain)
+        throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+      return ethereumChain.switchChain(chainId);
+    },
+    [ethereumChain]
+  );
+  const getChainId = (0, import_react6.useCallback)(async () => {
+    if (!ethereumChain)
+      throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+    return ethereumChain.getChainId();
+  }, [ethereumChain]);
+  const getAccounts = (0, import_react6.useCallback)(async () => {
+    if (!ethereumChain)
+      throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+    return ethereumChain.getAccounts();
+  }, [ethereumChain]);
+  const signMessage = (0, import_react6.useCallback)(
+    async (message) => {
+      return request({
+        method: "eth_sign",
+        params: [await getAccounts().then((accounts) => accounts[0]), message]
+      });
+    },
+    [request, getAccounts]
+  );
+  const signTypedData = (0, import_react6.useCallback)(
+    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
-var import_browser_sdk2 = require("@phantom/browser-sdk");
+var import_browser_sdk3 = require("@phantom/browser-sdk");