@phantom/react-sdk 0.3.8 → 1.0.0-beta.0

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 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 * as _phantom_parsers from '@phantom/parsers';
+import { ISolanaChain, IEthereumChain, EthTransactionRequest } from '@phantom/chains';
+export { EthTransactionRequest, IEthereumChain, ISolanaChain } from '@phantom/chains';
 
 interface PhantomSDKConfig extends BrowserSDKConfig {
 }
@@ -32,7 +35,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,18 +48,6 @@ 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;
 
 declare function useIsExtensionInstalled(): {
@@ -64,6 +55,61 @@ declare function useIsExtensionInstalled(): {
     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<_phantom_parsers.ParsedSignatureResult>;
+    signTransaction: <T>(transaction: T) => Promise<T>;
+    signAndSendTransaction: <T>(transaction: T) => Promise<_phantom_parsers.ParsedTransactionResult>;
+    connect: (options?: {
+        onlyIfTrusted?: boolean;
+    }) => Promise<{
+        publicKey: string;
+    }>;
+    disconnect: () => Promise<void>;
+    switchNetwork: (network: "mainnet" | "devnet") => Promise<void>;
+    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<_phantom_parsers.ParsedTransactionResult>;
+    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);
 
@@ -122,9 +123,9 @@ function PhantomProvider({ children, config, debugConfig }) {
   (0, import_react.useEffect)(() => {
     if (!sdk)
       return;
-    const initialize = async () => {
+    const initialize = () => {
       try {
-        const available = await sdk.waitForPhantomExtension(1e3);
+        const available = import_browser_sdk.BrowserSDK.isPhantomInstalled();
         setIsPhantomAvailable(available);
       } catch (err) {
         console.error("Error checking Phantom extension:", err);
@@ -225,76 +226,6 @@ function useDisconnect() {
   };
 }
 
-// src/hooks/useSignMessage.ts
-var import_react4 = require("react");
-function useSignMessage() {
-  const { sdk } = usePhantom();
-  const [isSigning, setIsSigning] = (0, import_react4.useState)(false);
-  const [error, setError] = (0, import_react4.useState)(null);
-  const signMessage = (0, import_react4.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 signature = await sdk.signMessage(params);
-        return signature;
-      } catch (err) {
-        setError(err);
-        throw err;
-      } finally {
-        setIsSigning(false);
-      }
-    },
-    [sdk]
-  );
-  return {
-    signMessage,
-    isSigning,
-    error
-  };
-}
-
-// src/hooks/useSignAndSendTransaction.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);
-  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);
-      }
-    },
-    [sdk]
-  );
-  return {
-    signAndSendTransaction,
-    isSigning,
-    error
-  };
-}
-
 // src/hooks/useAccounts.ts
 function useAccounts() {
   const { addresses, isConnected } = usePhantom();
@@ -303,6 +234,7 @@ function useAccounts() {
 
 // src/hooks/useIsExtensionInstalled.ts
 var React = __toESM(require("react"));
+var import_browser_sdk2 = require("@phantom/browser-sdk");
 var cachedIsInstalled = null;
 function useIsExtensionInstalled() {
   const { sdk } = usePhantom();
@@ -318,10 +250,10 @@ function useIsExtensionInstalled() {
       setIsLoading(false);
       return;
     }
-    const checkExtension = async () => {
+    const checkExtension = () => {
       try {
         setIsLoading(true);
-        const result = await sdk.waitForPhantomExtension(1e3);
+        const result = import_browser_sdk2.BrowserSDK.isPhantomInstalled();
         cachedIsInstalled = result;
         setIsInstalled(result);
       } catch (error) {
@@ -336,5 +268,246 @@ function useIsExtensionInstalled() {
   return { isLoading, isInstalled };
 }
 
+// src/hooks/useAutoConfirm.ts
+var import_react4 = require("react");
+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 isInjected = currentProviderType === "injected";
+  const enable = (0, import_react4.useCallback)(
+    async (params) => {
+      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);
+        const result = await sdk.enableAutoConfirm(params);
+        setStatus(result);
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [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 {
+    enable,
+    disable,
+    status,
+    supportedChains,
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// src/hooks/useSolana.ts
+var import_react5 = require("react");
+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 (transaction) => {
+    if (!solanaChain)
+      throw new Error("Solana chain not available. Ensure SDK is connected.");
+    return solanaChain.signAndSendTransaction(transaction);
+  }, [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,
+    connect,
+    disconnect,
+    switchNetwork,
+    getPublicKey,
+    // State
+    isAvailable: !!solanaChain,
+    isConnected: solanaChain?.isConnected() ?? false
+  };
+}
+
+// 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;
+    }
+  }, [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");