@phantom/react-sdk 0.0.10 → 0.1.0

package/dist/index.d.ts

@@ -1,18 +1,75 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { CreatePhantomConfig, Phantom } from '@phantom/browser-sdk';
-import * as React from 'react';
-
-type PhantomContextType = {
-    phantom: undefined;
-    isReady: false;
-} | {
-    phantom: Phantom;
-    isReady: true;
+import { ReactNode } from 'react';
+import * as _phantom_browser_sdk from '@phantom/browser-sdk';
+import { BrowserSDKConfig, BrowserSDK, WalletAddress, NetworkId, SignAndSendTransactionParams, SignedTransaction, CreateUserOrganizationParams, CreateUserOrganizationResult } from '@phantom/browser-sdk';
+export { AddressType, CreateUserOrganizationParams, CreateUserOrganizationResult, NetworkId, SignAndSendTransactionParams, SignMessageParams, SignedTransaction, WalletAddress } from '@phantom/browser-sdk';
+
+interface PhantomSDKConfig extends BrowserSDKConfig {
+}
+interface ConnectOptions {
+    providerType?: "injected" | "embedded";
+    embeddedWalletType?: "app-wallet" | "user-wallet";
+}
+interface PhantomContextValue {
+    sdk: BrowserSDK | null;
+    isConnected: boolean;
+    addresses: WalletAddress[];
+    walletId: string | null;
+    isReady: boolean;
+    error: Error | null;
+    currentProviderType: "injected" | "embedded" | null;
+    isPhantomAvailable: boolean;
+    updateConnectionState: () => Promise<void>;
+}
+interface PhantomProviderProps {
+    children: ReactNode;
+    config: PhantomSDKConfig;
+}
+declare function PhantomProvider({ children, config }: PhantomProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePhantom(): PhantomContextValue;
+
+declare function useConnect(): {
+    connect: (options?: ConnectOptions) => Promise<_phantom_browser_sdk.ConnectResult>;
+    switchProvider: (type: "injected" | "embedded", options?: {
+        embeddedWalletType?: "app-wallet" | "user-wallet";
+    }) => Promise<void>;
+    isConnecting: boolean;
+    error: Error | null;
+    currentProviderType: "injected" | "embedded" | null;
+    isPhantomAvailable: boolean;
+};
+
+declare function useDisconnect(): {
+    disconnect: () => Promise<void>;
+    isDisconnecting: boolean;
+    error: Error | null;
+};
+
+declare function useSignMessage(): {
+    signMessage: (message: string, networkId: NetworkId) => Promise<string>;
+    isSigning: boolean;
+    error: Error | null;
+};
+
+declare function useSignAndSendTransaction(): {
+    signAndSendTransaction: (params: SignAndSendTransactionParams) => Promise<SignedTransaction>;
+    isSigning: boolean;
+    error: Error | null;
+};
+
+declare function useAccounts(): _phantom_browser_sdk.WalletAddress[] | null;
+
+declare function useCreateUserOrganization(): {
+    createUserOrganization: (params: CreateUserOrganizationParams) => Promise<CreateUserOrganizationResult>;
+    isCreating: boolean;
+    error: Error | null;
 };
-declare const PhantomProvider: ({ children, config }: {
-    children: React.ReactNode;
-    config: CreatePhantomConfig;
-}) => react_jsx_runtime.JSX.Element;
-declare function usePhantom(): PhantomContextType;
 
-export { PhantomProvider, usePhantom };
+declare function useIsExtensionInstalled(): {
+    isLoading: boolean;
+    isInstalled: boolean;
+};
+
+type ProviderType = "injected" | "embedded";
+
+export { ConnectOptions, PhantomProvider, PhantomProviderProps, PhantomSDKConfig, ProviderType, useAccounts, useConnect, useCreateUserOrganization, useDisconnect, useIsExtensionInstalled, usePhantom, useSignAndSendTransaction, useSignMessage };

package/dist/index.js

@@ -30,33 +30,327 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AddressType: () => import_browser_sdk2.AddressType,
+  NetworkId: () => import_browser_sdk2.NetworkId,
   PhantomProvider: () => PhantomProvider,
-  usePhantom: () => usePhantom
+  useAccounts: () => useAccounts,
+  useConnect: () => useConnect,
+  useCreateUserOrganization: () => useCreateUserOrganization,
+  useDisconnect: () => useDisconnect,
+  useIsExtensionInstalled: () => useIsExtensionInstalled,
+  usePhantom: () => usePhantom,
+  useSignAndSendTransaction: () => useSignAndSendTransaction,
+  useSignMessage: () => useSignMessage
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/PhantomContext.tsx
+// src/PhantomProvider.tsx
+var import_react = require("react");
 var import_browser_sdk = require("@phantom/browser-sdk");
-var React = __toESM(require("react"));
 var import_jsx_runtime = require("react/jsx-runtime");
-var PhantomContext = React.createContext({ phantom: void 0, isReady: false });
-var PhantomProvider = ({ children, config }) => {
-  const [context, setContext] = React.useState({ phantom: void 0, isReady: false });
-  React.useEffect(() => {
-    const phantom = (0, import_browser_sdk.createPhantom)(config);
-    setContext({ phantom, isReady: true });
+var PhantomContext = (0, import_react.createContext)(void 0);
+function PhantomProvider({ children, config }) {
+  const [sdk, setSdk] = (0, import_react.useState)(null);
+  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
+  const [addresses, setAddresses] = (0, import_react.useState)([]);
+  const [walletId, setWalletId] = (0, import_react.useState)(null);
+  const [isReady, setIsReady] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [currentProviderType, setCurrentProviderType] = (0, import_react.useState)(null);
+  const [isPhantomAvailable, setIsPhantomAvailable] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    try {
+      const browserConfig = {
+        ...config,
+        // Use providerType if provided, default to embedded
+        providerType: config.providerType || "embedded"
+      };
+      const browserSDK = new import_browser_sdk.BrowserSDK(browserConfig);
+      setSdk(browserSDK);
+      const initialProviderInfo = browserSDK.getCurrentProviderInfo();
+      setCurrentProviderType(initialProviderInfo?.type || null);
+      const checkPhantom = async () => {
+        const available = await browserSDK.waitForPhantomExtension(1e3);
+        setIsPhantomAvailable(available);
+      };
+      checkPhantom();
+      setIsReady(true);
+    } catch (err) {
+      setError(err);
+      setIsReady(true);
+    }
   }, [config]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PhantomContext.Provider, { value: context, children });
-};
+  const updateConnectionState = (0, import_react.useCallback)(async () => {
+    if (sdk) {
+      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);
+      }
+    }
+  }, [sdk]);
+  (0, import_react.useEffect)(() => {
+    updateConnectionState();
+  }, [updateConnectionState]);
+  (0, import_react.useEffect)(() => {
+    if (sdk) {
+      sdk._updateConnectionState = updateConnectionState;
+    }
+  }, [sdk, updateConnectionState]);
+  const value = {
+    sdk,
+    isConnected,
+    addresses,
+    updateConnectionState,
+    walletId,
+    isReady,
+    error,
+    currentProviderType,
+    isPhantomAvailable
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PhantomContext.Provider, { value, children });
+}
 function usePhantom() {
-  const context = React.useContext(PhantomContext);
+  const context = (0, import_react.useContext)(PhantomContext);
   if (!context) {
     throw new Error("usePhantom must be used within a PhantomProvider");
   }
   return context;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PhantomProvider,
-  usePhantom
-});
+
+// src/hooks/useConnect.ts
+var import_react2 = require("react");
+function useConnect() {
+  const context = usePhantom();
+  const [isConnecting, setIsConnecting] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const connect = (0, import_react2.useCallback)(
+    async (options) => {
+      if (!context.sdk || !context.isReady) {
+        throw new Error("SDK not initialized");
+      }
+      setIsConnecting(true);
+      setError(null);
+      try {
+        const result = await context.sdk.connect(options);
+        if (context.sdk._updateConnectionState) {
+          await context.sdk._updateConnectionState();
+        }
+        return result;
+      } catch (err) {
+        console.error("Error connecting to Phantom:", err);
+        setError(err);
+        throw err;
+      } finally {
+        setIsConnecting(false);
+      }
+    },
+    [context.sdk, context.isReady]
+  );
+  const switchProvider = (0, import_react2.useCallback)(
+    async (type, options) => {
+      if (!context.sdk || !context.isReady) {
+        throw new Error("SDK not initialized");
+      }
+      await context.sdk.switchProvider(type, options);
+      if (context.sdk._updateConnectionState) {
+        await context.sdk._updateConnectionState();
+      }
+    },
+    [context.sdk, context.isReady]
+  );
+  return {
+    connect,
+    switchProvider,
+    isConnecting,
+    error,
+    currentProviderType: context.currentProviderType,
+    isPhantomAvailable: context.isPhantomAvailable
+  };
+}
+
+// src/hooks/useDisconnect.ts
+var import_react3 = require("react");
+function useDisconnect() {
+  const { sdk, isReady, updateConnectionState } = usePhantom();
+  const [isDisconnecting, setIsDisconnecting] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const disconnect = (0, import_react3.useCallback)(async () => {
+    if (!sdk || !isReady) {
+      throw new Error("SDK not initialized");
+    }
+    setIsDisconnecting(true);
+    setError(null);
+    try {
+      await sdk.disconnect();
+      await updateConnectionState();
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsDisconnecting(false);
+    }
+  }, [sdk, isReady, updateConnectionState]);
+  return {
+    disconnect,
+    isDisconnecting,
+    error
+  };
+}
+
+// src/hooks/useSignMessage.ts
+var import_react4 = require("react");
+function useSignMessage() {
+  const { sdk, isConnected } = usePhantom();
+  const [isSigning, setIsSigning] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const signMessage = (0, import_react4.useCallback)(
+    async (message, networkId) => {
+      if (!sdk) {
+        throw new Error("SDK not initialized");
+      }
+      if (!isConnected) {
+        throw new Error("Wallet not connected");
+      }
+      setIsSigning(true);
+      setError(null);
+      try {
+        const signature = await sdk.signMessage(message, networkId);
+        return signature;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsSigning(false);
+      }
+    },
+    [sdk, isConnected]
+  );
+  return {
+    signMessage,
+    isSigning,
+    error
+  };
+}
+
+// src/hooks/useSignAndSendTransaction.ts
+var import_react5 = require("react");
+function useSignAndSendTransaction() {
+  const { sdk, isConnected } = 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 (!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, isConnected]
+  );
+  return {
+    signAndSendTransaction,
+    isSigning,
+    error
+  };
+}
+
+// src/hooks/useAccounts.ts
+function useAccounts() {
+  const { addresses, isConnected } = usePhantom();
+  return isConnected ? addresses : null;
+}
+
+// src/hooks/useCreateUserOrganization.ts
+var import_react6 = require("react");
+function useCreateUserOrganization() {
+  const { sdk } = usePhantom();
+  const [isCreating, setIsCreating] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const createUserOrganization = (0, import_react6.useCallback)(
+    async (params) => {
+      if (!sdk) {
+        throw new Error("SDK not initialized");
+      }
+      setIsCreating(true);
+      setError(null);
+      try {
+        const result = await sdk.createUserOrganization(params);
+        return result;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [sdk]
+  );
+  return {
+    createUserOrganization,
+    isCreating,
+    error
+  };
+}
+
+// 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;
+    }
+    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 };
+}
+
+// src/index.ts
+var import_browser_sdk2 = require("@phantom/browser-sdk");