@phantom/react-sdk 0.3.4 → 0.3.6

package/README.md

@@ -641,7 +641,7 @@ interface PhantomSDKConfig {
   providerType: "injected" | "embedded";
   appName?: string; // Optional app name for branding
   appLogo?: string; // Optional app logo URL for branding
-  addressTypes?: AddressType[]; // Networks to enable (e.g., [AddressType.solana])
+  addressTypes?: [AddressType, ...AddressType[]]; // Networks to enable (e.g., [AddressType.solana])
 
   // Required for embedded provider only
   apiBaseUrl?: string; // Phantom API base URL
@@ -652,13 +652,70 @@ interface PhantomSDKConfig {
   };
   embeddedWalletType?: "app-wallet" | "user-wallet"; // Wallet type
   solanaProvider?: "web3js" | "kit"; // Solana library choice (default: 'web3js')
+  autoConnect?: boolean; // Auto-connect to existing session on SDK instantiation (default: true for embedded, false for injected)
+}
+```
+
+## Debug Configuration
+
+The React SDK supports separate debug configuration that can be changed without reinstantiating the underlying SDK, providing better performance.
+
+### PhantomDebugConfig Interface
+
+```typescript
+interface PhantomDebugConfig {
+  enabled?: boolean;     // Enable debug logging
+  level?: DebugLevel;    // Debug level (ERROR, WARN, INFO, DEBUG)
+  callback?: DebugCallback; // Custom debug message handler
+}
+```
+
+### Using Debug Configuration
+
+Pass the `debugConfig` as a separate prop to `PhantomProvider`:
+
+```typescript
+import { PhantomProvider, type PhantomSDKConfig, type PhantomDebugConfig, DebugLevel } from "@phantom/react-sdk";
+
+function App() {
+  const [debugLevel, setDebugLevel] = useState(DebugLevel.INFO);
+  const [debugMessages, setDebugMessages] = useState([]);
 
-  // Debug options
-  debug?: {
-    enabled?: boolean; // Enable debug logging
-    level?: "info" | "warn" | "error"; // Debug level
-    callback?: (level: string, message: string, data?: any) => void; // Custom debug callback
+  // SDK configuration - static, won't change when debug settings change
+  const config: PhantomSDKConfig = {
+    providerType: "embedded",
+    organizationId: "your-org-id",
+    // ... other config
+  };
+
+  // Debug configuration - separate to avoid SDK reinstantiation
+  const debugConfig: PhantomDebugConfig = {
+    enabled: true,
+    level: debugLevel,
+    callback: (message) => {
+      setDebugMessages(prev => [...prev, message]);
+    }
   };
+
+  return (
+    <PhantomProvider config={config} debugConfig={debugConfig}>
+      {/* Your app components */}
+    </PhantomProvider>
+  );
+}
+```
+
+### Debug Message Structure
+
+Debug callbacks receive a `DebugMessage` object:
+
+```typescript
+interface DebugMessage {
+  timestamp: number;     // Unix timestamp
+  level: DebugLevel;     // Message level
+  category: string;      // Component category
+  message: string;       // Debug message text
+  data?: any;           // Additional debug data (optional)
 }
 ```
 

package/dist/index.d.ts

@@ -1,31 +1,34 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { BrowserSDKConfig, AuthOptions, BrowserSDK, WalletAddress, SignMessageParams, SignMessageResult, SignAndSendTransactionParams, SignedTransaction } from '@phantom/browser-sdk';
+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 * as _phantom_embedded_provider_core from '@phantom/embedded-provider-core';
 
 interface PhantomSDKConfig extends BrowserSDKConfig {
 }
+interface PhantomDebugConfig extends DebugConfig {
+}
 interface ConnectOptions {
     providerType?: "injected" | "embedded";
     embeddedWalletType?: "app-wallet" | "user-wallet";
     authOptions?: AuthOptions;
 }
 interface PhantomContextValue {
-    sdk: BrowserSDK;
+    sdk: BrowserSDK | null;
     isConnected: boolean;
+    isConnecting: boolean;
+    connectError: Error | null;
     addresses: WalletAddress[];
     walletId: string | null;
-    error: Error | null;
     currentProviderType: "injected" | "embedded" | null;
     isPhantomAvailable: boolean;
-    updateConnectionState: () => Promise<void>;
 }
 interface PhantomProviderProps {
     children: ReactNode;
     config: PhantomSDKConfig;
+    debugConfig?: PhantomDebugConfig;
 }
-declare function PhantomProvider({ children, config }: PhantomProviderProps): react_jsx_runtime.JSX.Element;
+declare function PhantomProvider({ children, config, debugConfig }: PhantomProviderProps): react_jsx_runtime.JSX.Element;
 declare function usePhantom(): PhantomContextValue;
 
 declare function useConnect(): {
@@ -63,4 +66,4 @@ declare function useIsExtensionInstalled(): {
 
 type ProviderType = "injected" | "embedded";
 
-export { ConnectOptions, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, ProviderType, useAccounts, useConnect, useDisconnect, useIsExtensionInstalled, usePhantom, useSignAndSendTransaction, useSignMessage };
+export { ConnectOptions, PhantomDebugConfig, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, ProviderType, useAccounts, useConnect, useDisconnect, useIsExtensionInstalled, usePhantom, useSignAndSendTransaction, useSignMessage };

package/dist/index.js

@@ -50,49 +50,78 @@ var import_react = require("react");
 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 }) {
-  const sdk = (0, import_react.useMemo)(
-    () => new import_browser_sdk.BrowserSDK({
-      ...config,
-      // Use providerType if provided, default to embedded
-      providerType: config.providerType || "embedded"
-    }),
-    [config]
-  );
+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 [error, setError] = (0, import_react.useState)(null);
   const [currentProviderType, setCurrentProviderType] = (0, import_react.useState)(null);
   const [isPhantomAvailable, setIsPhantomAvailable] = (0, import_react.useState)(false);
-  const updateConnectionState = (0, import_react.useCallback)(async () => {
-    try {
-      const connected = sdk.isConnected();
-      setIsConnected(connected);
-      const providerInfo = sdk.getCurrentProviderInfo();
-      setCurrentProviderType(providerInfo?.type || null);
-      if (connected) {
-        const addrs = await sdk.getAddresses();
-        setAddresses(addrs);
-        setWalletId(sdk.getWalletId());
-      } else {
-        setAddresses([]);
-        setWalletId(null);
-      }
-    } catch (err) {
-      console.error("Error updating connection state:", err);
-      setError(err);
+  const [sdk, setSdk] = (0, import_react.useState)(null);
+  const memoizedConfig = (0, import_react.useMemo)(() => {
+    return {
+      ...config,
+      // Use providerType if provided, default to embedded
+      providerType: config.providerType || "embedded"
+    };
+  }, [config]);
+  (0, import_react.useEffect)(() => {
+    const sdkInstance = new import_browser_sdk.BrowserSDK(memoizedConfig);
+    const handleConnectStart = () => {
+      setIsConnecting(true);
+      setConnectError(null);
+    };
+    const handleConnect = async () => {
       try {
-        await sdk.disconnect();
-        setIsConnected(false);
-        setAddresses([]);
-        setWalletId(null);
-      } catch (err2) {
-        console.error("Error disconnecting:", err2);
+        setIsConnected(true);
+        setIsConnecting(false);
+        const providerInfo = sdkInstance.getCurrentProviderInfo();
+        setCurrentProviderType(providerInfo?.type || null);
+        const addrs = await sdkInstance.getAddresses();
+        setAddresses(addrs);
+        setWalletId(sdkInstance.getWalletId());
+      } catch (err) {
+        console.error("Error connecting:", err);
+        try {
+          await sdkInstance.disconnect();
+        } catch (err2) {
+          console.error("Error disconnecting:", err2);
+        }
       }
-    }
-  }, [sdk]);
+    };
+    const handleConnectError = (errorData) => {
+      setIsConnecting(false);
+      setIsConnected(false);
+      setConnectError(new Error(errorData.error || "Connection failed"));
+    };
+    const handleDisconnect = () => {
+      setIsConnected(false);
+      setIsConnecting(false);
+      setConnectError(null);
+      setAddresses([]);
+      setWalletId(null);
+    };
+    sdkInstance.on("connect_start", handleConnectStart);
+    sdkInstance.on("connect", handleConnect);
+    sdkInstance.on("connect_error", handleConnectError);
+    sdkInstance.on("disconnect", handleDisconnect);
+    setSdk(sdkInstance);
+    return () => {
+      sdkInstance.off("connect_start", handleConnectStart);
+      sdkInstance.off("connect", handleConnect);
+      sdkInstance.off("connect_error", handleConnectError);
+      sdkInstance.off("disconnect", handleDisconnect);
+    };
+  }, [memoizedConfig]);
+  (0, import_react.useEffect)(() => {
+    if (!sdk || !debugConfig)
+      return;
+    sdk.configureDebug(debugConfig);
+  }, [sdk, debugConfig]);
   (0, import_react.useEffect)(() => {
+    if (!sdk)
+      return;
     const initialize = async () => {
       try {
         const available = await sdk.waitForPhantomExtension(1e3);
@@ -101,28 +130,31 @@ function PhantomProvider({ children, config }) {
         console.error("Error checking Phantom extension:", err);
         setIsPhantomAvailable(false);
       }
-      await updateConnectionState();
+      if (config.autoConnect !== false) {
+        sdk.autoConnect().catch(() => {
+        });
+      }
     };
     initialize();
-  }, [sdk, updateConnectionState]);
+  }, [sdk, config.autoConnect]);
   const value = (0, import_react.useMemo)(
     () => ({
       sdk,
       isConnected,
+      isConnecting,
+      connectError,
       addresses,
-      updateConnectionState,
       walletId,
-      error,
       currentProviderType,
       isPhantomAvailable
     }),
     [
       sdk,
       isConnected,
+      isConnecting,
+      connectError,
       addresses,
-      updateConnectionState,
       walletId,
-      error,
       currentProviderType,
       isPhantomAvailable
     ]
@@ -140,34 +172,26 @@ function usePhantom() {
 // src/hooks/useConnect.ts
 var import_react2 = require("react");
 function useConnect() {
-  const { sdk, updateConnectionState, currentProviderType, isPhantomAvailable } = usePhantom();
-  const [isConnecting, setIsConnecting] = (0, import_react2.useState)(false);
-  const [error, setError] = (0, import_react2.useState)(null);
+  const { sdk, isConnecting, connectError, currentProviderType, isPhantomAvailable } = usePhantom();
   const connect = (0, import_react2.useCallback)(
     async (options) => {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      setIsConnecting(true);
-      setError(null);
       try {
         const result = await sdk.connect(options);
-        await updateConnectionState();
         return result;
       } catch (err) {
         console.error("Error connecting to Phantom:", err);
-        setError(err);
         throw err;
-      } finally {
-        setIsConnecting(false);
       }
     },
-    [sdk, updateConnectionState]
+    [sdk]
   );
   return {
     connect,
     isConnecting,
-    error,
+    error: connectError,
     currentProviderType,
     isPhantomAvailable
   };
@@ -176,7 +200,7 @@ function useConnect() {
 // src/hooks/useDisconnect.ts
 var import_react3 = require("react");
 function useDisconnect() {
-  const { sdk, updateConnectionState } = usePhantom();
+  const { sdk } = usePhantom();
   const [isDisconnecting, setIsDisconnecting] = (0, import_react3.useState)(false);
   const [error, setError] = (0, import_react3.useState)(null);
   const disconnect = (0, import_react3.useCallback)(async () => {
@@ -187,14 +211,13 @@ function useDisconnect() {
     setError(null);
     try {
       await sdk.disconnect();
-      await updateConnectionState();
     } catch (err) {
       setError(err);
       throw err;
     } finally {
       setIsDisconnecting(false);
     }
-  }, [sdk, updateConnectionState]);
+  }, [sdk]);
   return {
     disconnect,
     isDisconnecting,
@@ -205,7 +228,7 @@ function useDisconnect() {
 // src/hooks/useSignMessage.ts
 var import_react4 = require("react");
 function useSignMessage() {
-  const { sdk, isConnected } = usePhantom();
+  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)(
@@ -213,7 +236,7 @@ function useSignMessage() {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      if (!isConnected) {
+      if (!sdk.isConnected()) {
         throw new Error("Wallet not connected");
       }
       setIsSigning(true);
@@ -228,7 +251,7 @@ function useSignMessage() {
         setIsSigning(false);
       }
     },
-    [sdk, isConnected]
+    [sdk]
   );
   return {
     signMessage,
@@ -240,7 +263,7 @@ function useSignMessage() {
 // src/hooks/useSignAndSendTransaction.ts
 var import_react5 = require("react");
 function useSignAndSendTransaction() {
-  const { sdk, isConnected } = usePhantom();
+  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)(
@@ -248,7 +271,7 @@ function useSignAndSendTransaction() {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      if (!isConnected) {
+      if (!sdk.isConnected()) {
         throw new Error("Wallet not connected");
       }
       setIsSigning(true);
@@ -263,7 +286,7 @@ function useSignAndSendTransaction() {
         setIsSigning(false);
       }
     },
-    [sdk, isConnected]
+    [sdk]
   );
   return {
     signAndSendTransaction,

package/dist/index.mjs

@@ -1,51 +1,80 @@
 // src/PhantomProvider.tsx
-import { createContext, useContext, useState, useEffect, useCallback, useMemo } from "react";
+import { createContext, useContext, useState, useEffect, useMemo } from "react";
 import { BrowserSDK } from "@phantom/browser-sdk";
 import { jsx } from "react/jsx-runtime";
 var PhantomContext = createContext(void 0);
-function PhantomProvider({ children, config }) {
-  const sdk = useMemo(
-    () => new BrowserSDK({
-      ...config,
-      // Use providerType if provided, default to embedded
-      providerType: config.providerType || "embedded"
-    }),
-    [config]
-  );
+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 [error, setError] = useState(null);
   const [currentProviderType, setCurrentProviderType] = useState(null);
   const [isPhantomAvailable, setIsPhantomAvailable] = useState(false);
-  const updateConnectionState = useCallback(async () => {
-    try {
-      const connected = sdk.isConnected();
-      setIsConnected(connected);
-      const providerInfo = sdk.getCurrentProviderInfo();
-      setCurrentProviderType(providerInfo?.type || null);
-      if (connected) {
-        const addrs = await sdk.getAddresses();
-        setAddresses(addrs);
-        setWalletId(sdk.getWalletId());
-      } else {
-        setAddresses([]);
-        setWalletId(null);
-      }
-    } catch (err) {
-      console.error("Error updating connection state:", err);
-      setError(err);
+  const [sdk, setSdk] = useState(null);
+  const memoizedConfig = useMemo(() => {
+    return {
+      ...config,
+      // Use providerType if provided, default to embedded
+      providerType: config.providerType || "embedded"
+    };
+  }, [config]);
+  useEffect(() => {
+    const sdkInstance = new BrowserSDK(memoizedConfig);
+    const handleConnectStart = () => {
+      setIsConnecting(true);
+      setConnectError(null);
+    };
+    const handleConnect = async () => {
       try {
-        await sdk.disconnect();
-        setIsConnected(false);
-        setAddresses([]);
-        setWalletId(null);
-      } catch (err2) {
-        console.error("Error disconnecting:", err2);
+        setIsConnected(true);
+        setIsConnecting(false);
+        const providerInfo = sdkInstance.getCurrentProviderInfo();
+        setCurrentProviderType(providerInfo?.type || null);
+        const addrs = await sdkInstance.getAddresses();
+        setAddresses(addrs);
+        setWalletId(sdkInstance.getWalletId());
+      } catch (err) {
+        console.error("Error connecting:", err);
+        try {
+          await sdkInstance.disconnect();
+        } catch (err2) {
+          console.error("Error disconnecting:", err2);
+        }
       }
-    }
-  }, [sdk]);
+    };
+    const handleConnectError = (errorData) => {
+      setIsConnecting(false);
+      setIsConnected(false);
+      setConnectError(new Error(errorData.error || "Connection failed"));
+    };
+    const handleDisconnect = () => {
+      setIsConnected(false);
+      setIsConnecting(false);
+      setConnectError(null);
+      setAddresses([]);
+      setWalletId(null);
+    };
+    sdkInstance.on("connect_start", handleConnectStart);
+    sdkInstance.on("connect", handleConnect);
+    sdkInstance.on("connect_error", handleConnectError);
+    sdkInstance.on("disconnect", handleDisconnect);
+    setSdk(sdkInstance);
+    return () => {
+      sdkInstance.off("connect_start", handleConnectStart);
+      sdkInstance.off("connect", handleConnect);
+      sdkInstance.off("connect_error", handleConnectError);
+      sdkInstance.off("disconnect", handleDisconnect);
+    };
+  }, [memoizedConfig]);
   useEffect(() => {
+    if (!sdk || !debugConfig)
+      return;
+    sdk.configureDebug(debugConfig);
+  }, [sdk, debugConfig]);
+  useEffect(() => {
+    if (!sdk)
+      return;
     const initialize = async () => {
       try {
         const available = await sdk.waitForPhantomExtension(1e3);
@@ -54,28 +83,31 @@ function PhantomProvider({ children, config }) {
         console.error("Error checking Phantom extension:", err);
         setIsPhantomAvailable(false);
       }
-      await updateConnectionState();
+      if (config.autoConnect !== false) {
+        sdk.autoConnect().catch(() => {
+        });
+      }
     };
     initialize();
-  }, [sdk, updateConnectionState]);
+  }, [sdk, config.autoConnect]);
   const value = useMemo(
     () => ({
       sdk,
       isConnected,
+      isConnecting,
+      connectError,
       addresses,
-      updateConnectionState,
       walletId,
-      error,
       currentProviderType,
       isPhantomAvailable
     }),
     [
       sdk,
       isConnected,
+      isConnecting,
+      connectError,
       addresses,
-      updateConnectionState,
       walletId,
-      error,
       currentProviderType,
       isPhantomAvailable
     ]
@@ -91,48 +123,40 @@ function usePhantom() {
 }
 
 // src/hooks/useConnect.ts
-import { useCallback as useCallback2, useState as useState2 } from "react";
+import { useCallback } from "react";
 function useConnect() {
-  const { sdk, updateConnectionState, currentProviderType, isPhantomAvailable } = usePhantom();
-  const [isConnecting, setIsConnecting] = useState2(false);
-  const [error, setError] = useState2(null);
-  const connect = useCallback2(
+  const { sdk, isConnecting, connectError, currentProviderType, isPhantomAvailable } = usePhantom();
+  const connect = useCallback(
     async (options) => {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      setIsConnecting(true);
-      setError(null);
       try {
         const result = await sdk.connect(options);
-        await updateConnectionState();
         return result;
       } catch (err) {
         console.error("Error connecting to Phantom:", err);
-        setError(err);
         throw err;
-      } finally {
-        setIsConnecting(false);
       }
     },
-    [sdk, updateConnectionState]
+    [sdk]
   );
   return {
     connect,
     isConnecting,
-    error,
+    error: connectError,
     currentProviderType,
     isPhantomAvailable
   };
 }
 
 // src/hooks/useDisconnect.ts
-import { useCallback as useCallback3, useState as useState3 } from "react";
+import { useCallback as useCallback2, useState as useState2 } from "react";
 function useDisconnect() {
-  const { sdk, updateConnectionState } = usePhantom();
-  const [isDisconnecting, setIsDisconnecting] = useState3(false);
-  const [error, setError] = useState3(null);
-  const disconnect = useCallback3(async () => {
+  const { sdk } = usePhantom();
+  const [isDisconnecting, setIsDisconnecting] = useState2(false);
+  const [error, setError] = useState2(null);
+  const disconnect = useCallback2(async () => {
     if (!sdk) {
       throw new Error("SDK not initialized");
     }
@@ -140,14 +164,13 @@ function useDisconnect() {
     setError(null);
     try {
       await sdk.disconnect();
-      await updateConnectionState();
     } catch (err) {
       setError(err);
       throw err;
     } finally {
       setIsDisconnecting(false);
     }
-  }, [sdk, updateConnectionState]);
+  }, [sdk]);
   return {
     disconnect,
     isDisconnecting,
@@ -156,17 +179,17 @@ function useDisconnect() {
 }
 
 // src/hooks/useSignMessage.ts
-import { useCallback as useCallback4, useState as useState4 } from "react";
+import { useCallback as useCallback3, useState as useState3 } from "react";
 function useSignMessage() {
-  const { sdk, isConnected } = usePhantom();
-  const [isSigning, setIsSigning] = useState4(false);
-  const [error, setError] = useState4(null);
-  const signMessage = useCallback4(
+  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 (!isConnected) {
+      if (!sdk.isConnected()) {
         throw new Error("Wallet not connected");
       }
       setIsSigning(true);
@@ -181,7 +204,7 @@ function useSignMessage() {
         setIsSigning(false);
       }
     },
-    [sdk, isConnected]
+    [sdk]
   );
   return {
     signMessage,
@@ -191,17 +214,17 @@ function useSignMessage() {
 }
 
 // src/hooks/useSignAndSendTransaction.ts
-import { useCallback as useCallback5, useState as useState5 } from "react";
+import { useCallback as useCallback4, useState as useState4 } from "react";
 function useSignAndSendTransaction() {
-  const { sdk, isConnected } = usePhantom();
-  const [isSigning, setIsSigning] = useState5(false);
-  const [error, setError] = useState5(null);
-  const signAndSendTransaction = useCallback5(
+  const { sdk } = usePhantom();
+  const [isSigning, setIsSigning] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signAndSendTransaction = useCallback4(
     async (params) => {
       if (!sdk) {
         throw new Error("SDK not initialized");
       }
-      if (!isConnected) {
+      if (!sdk.isConnected()) {
         throw new Error("Wallet not connected");
       }
       setIsSigning(true);
@@ -216,7 +239,7 @@ function useSignAndSendTransaction() {
         setIsSigning(false);
       }
     },
-    [sdk, isConnected]
+    [sdk]
   );
   return {
     signAndSendTransaction,

package/package.json

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