@phantom/react-sdk 0.0.9 → 0.1.0

package/dist/index.mjs

@@ -1,8 +1,323 @@
-import {
-  PhantomProvider,
-  usePhantom
-} from "./chunk-5KSEZ3MC.mjs";
+// src/PhantomProvider.tsx
+import { createContext, useContext, useState, useEffect, useCallback } 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, setSdk] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [addresses, setAddresses] = useState([]);
+  const [walletId, setWalletId] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  const [error, setError] = useState(null);
+  const [currentProviderType, setCurrentProviderType] = useState(null);
+  const [isPhantomAvailable, setIsPhantomAvailable] = useState(false);
+  useEffect(() => {
+    try {
+      const browserConfig = {
+        ...config,
+        // Use providerType if provided, default to embedded
+        providerType: config.providerType || "embedded"
+      };
+      const browserSDK = new 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]);
+  const updateConnectionState = 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]);
+  useEffect(() => {
+    updateConnectionState();
+  }, [updateConnectionState]);
+  useEffect(() => {
+    if (sdk) {
+      sdk._updateConnectionState = updateConnectionState;
+    }
+  }, [sdk, updateConnectionState]);
+  const value = {
+    sdk,
+    isConnected,
+    addresses,
+    updateConnectionState,
+    walletId,
+    isReady,
+    error,
+    currentProviderType,
+    isPhantomAvailable
+  };
+  return /* @__PURE__ */ jsx(PhantomContext.Provider, { value, children });
+}
+function usePhantom() {
+  const context = useContext(PhantomContext);
+  if (!context) {
+    throw new Error("usePhantom must be used within a PhantomProvider");
+  }
+  return context;
+}
+
+// src/hooks/useConnect.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+function useConnect() {
+  const context = usePhantom();
+  const [isConnecting, setIsConnecting] = useState2(false);
+  const [error, setError] = useState2(null);
+  const connect = useCallback2(
+    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 = useCallback2(
+    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
+import { useCallback as useCallback3, useState as useState3 } from "react";
+function useDisconnect() {
+  const { sdk, isReady, updateConnectionState } = usePhantom();
+  const [isDisconnecting, setIsDisconnecting] = useState3(false);
+  const [error, setError] = useState3(null);
+  const disconnect = useCallback3(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
+import { useCallback as useCallback4, useState as useState4 } from "react";
+function useSignMessage() {
+  const { sdk, isConnected } = usePhantom();
+  const [isSigning, setIsSigning] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signMessage = useCallback4(
+    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
+import { useCallback as useCallback5, useState as useState5 } from "react";
+function useSignAndSendTransaction() {
+  const { sdk, isConnected } = usePhantom();
+  const [isSigning, setIsSigning] = useState5(false);
+  const [error, setError] = useState5(null);
+  const signAndSendTransaction = useCallback5(
+    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
+import { useCallback as useCallback6, useState as useState6 } from "react";
+function useCreateUserOrganization() {
+  const { sdk } = usePhantom();
+  const [isCreating, setIsCreating] = useState6(false);
+  const [error, setError] = useState6(null);
+  const createUserOrganization = useCallback6(
+    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
+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;
+    }
+    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
+import { NetworkId, AddressType } from "@phantom/browser-sdk";
 export {
+  AddressType,
+  NetworkId,
   PhantomProvider,
-  usePhantom
+  useAccounts,
+  useConnect,
+  useCreateUserOrganization,
+  useDisconnect,
+  useIsExtensionInstalled,
+  usePhantom,
+  useSignAndSendTransaction,
+  useSignMessage
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/react-sdk",
-  "version": "0.0.9",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -9,16 +9,6 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    },
-    "./solana": {
-      "import": "./dist/solana/index.mjs",
-      "require": "./dist/solana/index.js",
-      "types": "./dist/solana/index.d.ts"
-    },
-    "./auto-confirm": {
-      "import": "./dist/auto-confirm/index.mjs",
-      "require": "./dist/auto-confirm/index.js",
-      "types": "./dist/auto-confirm/index.d.ts"
     }
   },
   "files": [
@@ -26,15 +16,16 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "rimraf ./dist && tsup src/index.ts src/solana/index.ts src/auto-confirm/index.ts --format cjs,esm --dts",
+    "build": "rimraf ./dist && tsup",
     "?pack-release": "When https://github.com/changesets/changesets/issues/432 has a solution we can remove this trick",
     "pack-release": "rimraf ./_release && yarn pack && mkdir ./_release && tar zxvf ./package.tgz --directory ./_release && rm ./package.tgz",
-    "dev": "rimraf ./dist && tsup src/index.ts src/solana/index.ts src/auto-confirm/index.ts --format cjs,esm --dts --watch",
+    "dev": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --watch",
     "lint": "tsc --noEmit && eslint --cache . --ext .ts,.tsx",
-    "test": "jest"
+    "test": "jest",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
   },
   "dependencies": {
-    "@phantom/browser-sdk": "^0.0.9"
+    "@phantom/browser-sdk": "^0.1.0"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.0",
@@ -45,6 +36,7 @@
     "eslint": "8.53.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
+    "prettier": "^3.5.2",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "rimraf": "^6.0.1",

package/dist/auto-confirm/index.d.ts

@@ -1,44 +0,0 @@
-import { AutoConfirmResult, NetworkID, AutoConfirmEnableParams } from '@phantom/browser-sdk/auto-confirm';
-export { AutoConfirmEnableParams, AutoConfirmResult, AutoConfirmSupportedChainsResult, NetworkID } from '@phantom/browser-sdk/auto-confirm';
-
-interface AutoConfirmState {
-    status: AutoConfirmResult | null;
-    supportedChains: NetworkID[] | null;
-    isLoading: boolean;
-    error: Error | null;
-}
-interface AutoConfirmActions {
-    enable: (params?: AutoConfirmEnableParams) => Promise<{
-        enabled: boolean;
-        chains: NetworkID[];
-    }>;
-    disable: () => Promise<{
-        enabled: boolean;
-        chains: NetworkID[];
-    }>;
-    getSupportedChains: () => Promise<{
-        chains: NetworkID[];
-    }>;
-    getStatus: () => Promise<{
-        enabled: boolean;
-        chains: NetworkID[];
-    }>;
-}
-
-/**
- * React hook that provides the current auto-confirm status and supported chains.
- * Automatically updates when auto-confirm is enabled or disabled.
- *
- * @returns Object containing status, supportedChains, isLoading, and error
- */
-declare function useAutoConfirmState(): AutoConfirmState;
-
-/**
- * React hook that provides actions to enable and disable auto-confirm.
- * Operations are async and will trigger state updates in useAutoConfirmState.
- *
- * @returns Object containing enable and disable functions
- */
-declare function useAutoConfirmActions(): AutoConfirmActions;
-
-export { AutoConfirmActions, AutoConfirmState, useAutoConfirmActions, useAutoConfirmState };

package/dist/auto-confirm/index.js

@@ -1,182 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/auto-confirm/index.ts
-var auto_confirm_exports = {};
-__export(auto_confirm_exports, {
-  useAutoConfirmActions: () => useAutoConfirmActions,
-  useAutoConfirmState: () => useAutoConfirmState
-});
-module.exports = __toCommonJS(auto_confirm_exports);
-var import_auto_confirm = require("@phantom/browser-sdk/auto-confirm");
-
-// src/auto-confirm/useAutoConfirmState.ts
-var React2 = __toESM(require("react"));
-
-// src/PhantomContext.tsx
-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 });
-function usePhantom() {
-  const context = React.useContext(PhantomContext);
-  if (!context) {
-    throw new Error("usePhantom must be used within a PhantomProvider");
-  }
-  return context;
-}
-
-// src/auto-confirm/assertions.ts
-function assertAutoConfirmConfigured(phantom) {
-  if (!phantom?.autoConfirm) {
-    throw new Error(
-      "Phantom auto-confirm plugin not found. Please ensure the auto-confirm plugin is installed and configured properly."
-    );
-  }
-}
-
-// src/auto-confirm/useAutoConfirmState.ts
-function useAutoConfirmState() {
-  const { phantom, isReady } = usePhantom();
-  const isMountedRef = React2.useRef(true);
-  const isInitializedRef = React2.useRef(false);
-  const [status, setStatus] = React2.useState(null);
-  const [supportedChains, setSupportedChains] = React2.useState(null);
-  const [isLoading, setIsLoading] = React2.useState(true);
-  const [error, setError] = React2.useState(null);
-  React2.useEffect(() => {
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-  const updateState = React2.useCallback(async () => {
-    if (!isReady || !isMountedRef.current)
-      return;
-    try {
-      assertAutoConfirmConfigured(phantom);
-      if (!isMountedRef.current)
-        return;
-      setError(null);
-      if (status === null && isMountedRef.current) {
-        setIsLoading(true);
-      }
-      const [statusResult, supportedChainsResult] = await Promise.all([
-        phantom.autoConfirm.autoConfirmStatus(),
-        phantom.autoConfirm.autoConfirmSupportedChains()
-      ]);
-      if (!isMountedRef.current)
-        return;
-      setStatus(statusResult);
-      setSupportedChains(supportedChainsResult.chains);
-    } catch (err) {
-      if (!isMountedRef.current)
-        return;
-      setError(err instanceof Error ? err : new Error("Failed to fetch auto-confirm state"));
-      setStatus(null);
-      setSupportedChains(null);
-    } finally {
-      if (isMountedRef.current) {
-        setIsLoading(false);
-      }
-    }
-  }, [phantom, isReady, status]);
-  React2.useEffect(() => {
-    if (!isInitializedRef.current && isReady) {
-      isInitializedRef.current = true;
-      updateState();
-    }
-    const handleStateChange = () => {
-      updateState();
-    };
-    window.addEventListener("phantomAutoConfirmStateChanged", handleStateChange);
-    return () => {
-      window.removeEventListener("phantomAutoConfirmStateChanged", handleStateChange);
-    };
-  }, [updateState, isReady]);
-  return {
-    status,
-    supportedChains,
-    isLoading,
-    error
-  };
-}
-
-// src/auto-confirm/useAutoConfirmActions.ts
-var React3 = __toESM(require("react"));
-function useAutoConfirmActions() {
-  const { phantom, isReady } = usePhantom();
-  const enable = React3.useCallback(
-    async (params) => {
-      if (!isReady) {
-        throw new Error("Phantom is not ready");
-      }
-      assertAutoConfirmConfigured(phantom);
-      const result = await phantom.autoConfirm.autoConfirmEnable(params);
-      window.dispatchEvent(new CustomEvent("phantomAutoConfirmStateChanged"));
-      return result;
-    },
-    [phantom, isReady]
-  );
-  const disable = React3.useCallback(async () => {
-    if (!isReady) {
-      throw new Error("Phantom is not ready");
-    }
-    assertAutoConfirmConfigured(phantom);
-    const result = await phantom.autoConfirm.autoConfirmDisable();
-    window.dispatchEvent(new CustomEvent("phantomAutoConfirmStateChanged"));
-    return result;
-  }, [phantom, isReady]);
-  const getSupportedChains = React3.useCallback(async () => {
-    if (!isReady) {
-      throw new Error("Phantom is not ready");
-    }
-    assertAutoConfirmConfigured(phantom);
-    const result = await phantom.autoConfirm.autoConfirmSupportedChains();
-    return result;
-  }, [phantom, isReady]);
-  const getStatus = React3.useCallback(async () => {
-    if (!isReady) {
-      throw new Error("Phantom is not ready");
-    }
-    assertAutoConfirmConfigured(phantom);
-    const result = await phantom.autoConfirm.autoConfirmStatus();
-    return result;
-  }, [phantom, isReady]);
-  return {
-    enable,
-    disable,
-    getSupportedChains,
-    getStatus
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useAutoConfirmActions,
-  useAutoConfirmState
-});