@phantom/react-native-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,479 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddressType: () => import_client.AddressType,
+  NetworkId: () => import_client.NetworkId,
+  PhantomProvider: () => PhantomProvider,
+  useAccounts: () => useAccounts,
+  useConnect: () => useConnect,
+  useDisconnect: () => useDisconnect,
+  usePhantom: () => usePhantom,
+  useSignAndSendTransaction: () => useSignAndSendTransaction,
+  useSignMessage: () => useSignMessage
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PhantomProvider.tsx
+var import_react = require("react");
+var import_embedded_provider_core = require("@phantom/embedded-provider-core");
+
+// src/providers/embedded/storage.ts
+var SecureStore = __toESM(require("expo-secure-store"));
+var ExpoSecureStorage = class {
+  constructor(requireAuth = false) {
+    this.sessionKey = "phantom_session";
+    this.requireAuth = requireAuth;
+  }
+  async saveSession(session) {
+    try {
+      await SecureStore.setItemAsync(this.sessionKey, JSON.stringify(session), {
+        requireAuthentication: this.requireAuth,
+        keychainAccessible: SecureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY
+      });
+    } catch (error) {
+      console.error("[ExpoSecureStorage] Failed to save session", { error: error.message });
+      throw new Error(`Failed to save session: ${error.message}`);
+    }
+  }
+  async getSession() {
+    try {
+      const sessionData = await SecureStore.getItemAsync(this.sessionKey, {
+        requireAuthentication: this.requireAuth
+      });
+      if (!sessionData) {
+        return null;
+      }
+      return JSON.parse(sessionData);
+    } catch (error) {
+      console.error("[ExpoSecureStorage] Failed to load session", { error: error.message });
+      return null;
+    }
+  }
+  async clearSession() {
+    try {
+      await SecureStore.deleteItemAsync(this.sessionKey);
+    } catch (error) {
+      console.error("[ExpoSecureStorage] Failed to clear session", { error: error.message });
+    }
+  }
+  async isAvailable() {
+    return await SecureStore.isAvailableAsync();
+  }
+  // Method to update authentication requirement
+  setRequireAuth(_requireAuth) {
+    console.warn("[ExpoSecureStorage] Cannot change requireAuth after initialization");
+  }
+};
+
+// src/providers/embedded/auth.ts
+var WebBrowser = __toESM(require("expo-web-browser"));
+var ExpoAuthProvider = class {
+  async authenticate(options) {
+    if ("jwtToken" in options) {
+      return;
+    }
+    const { authUrl, redirectUrl } = options;
+    if (!authUrl || !redirectUrl) {
+      throw new Error("authUrl and redirectUrl are required for web browser authentication");
+    }
+    try {
+      console.log("[ExpoAuthProvider] Starting authentication", {
+        authUrl: authUrl.substring(0, 50) + "...",
+        redirectUrl
+      });
+      await WebBrowser.warmUpAsync();
+      const result = await WebBrowser.openAuthSessionAsync(authUrl, redirectUrl, {
+        // Use system browser on iOS for ASWebAuthenticationSession
+        preferEphemeralSession: false
+      });
+      console.log("[ExpoAuthProvider] Authentication result", {
+        type: result.type,
+        url: result.type === "success" && result.url ? result.url.substring(0, 100) + "..." : void 0
+      });
+      if (result.type === "success" && result.url) {
+        const url = new URL(result.url);
+        const walletId = url.searchParams.get("walletId");
+        const provider = url.searchParams.get("provider");
+        if (!walletId) {
+          throw new Error("Authentication failed: no walletId in redirect URL");
+        }
+        const userInfo = {};
+        url.searchParams.forEach((value, key) => {
+          userInfo[key] = value;
+        });
+        return {
+          walletId,
+          provider: provider || void 0,
+          userInfo
+        };
+      } else if (result.type === "cancel") {
+        throw new Error("User cancelled authentication");
+      } else {
+        throw new Error("Authentication failed");
+      }
+    } catch (error) {
+      console.error("[ExpoAuthProvider] Authentication error", error);
+      throw error;
+    } finally {
+      await WebBrowser.coolDownAsync();
+    }
+  }
+  isAvailable() {
+    return Promise.resolve(true);
+  }
+};
+
+// src/providers/embedded/url-params.ts
+var import_react_native = require("react-native");
+var ExpoURLParamsAccessor = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscription = null;
+    this.currentParams = {};
+  }
+  getParam(key) {
+    return this.currentParams[key] || null;
+  }
+  async getInitialParams() {
+    try {
+      const url = await import_react_native.Linking.getInitialURL();
+      if (!url) {
+        return null;
+      }
+      const params = this.parseURLParams(url);
+      this.currentParams = params;
+      return params;
+    } catch (error) {
+      console.error("[ExpoURLParamsAccessor] Failed to get initial URL", error);
+      return null;
+    }
+  }
+  startListening() {
+    if (this.subscription) {
+      return;
+    }
+    this.subscription = import_react_native.Linking.addEventListener("url", ({ url }) => {
+      const params = this.parseURLParams(url);
+      if (params && Object.keys(params).length > 0) {
+        this.currentParams = { ...this.currentParams, ...params };
+        this.listeners.forEach((listener) => listener(params));
+      }
+    });
+  }
+  stopListening() {
+    if (this.subscription) {
+      this.subscription.remove();
+      this.subscription = null;
+    }
+  }
+  addListener(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  parseURLParams(url) {
+    try {
+      const parsed = new URL(url);
+      const params = {};
+      parsed.searchParams.forEach((value, key) => {
+        params[key] = value;
+      });
+      return params;
+    } catch (error) {
+      console.error("[ExpoURLParamsAccessor] Failed to parse URL", url, error);
+      return {};
+    }
+  }
+  dispose() {
+    this.stopListening();
+    this.listeners.clear();
+  }
+};
+
+// src/providers/embedded/logger.ts
+var ExpoLogger = class {
+  constructor(enabled = false) {
+    this.enabled = enabled;
+  }
+  info(category, message, data) {
+    if (this.enabled) {
+      console.info(`[${category}] ${message}`, data);
+    }
+  }
+  warn(category, message, data) {
+    if (this.enabled) {
+      console.warn(`[${category}] ${message}`, data);
+    }
+  }
+  error(category, message, data) {
+    if (this.enabled) {
+      console.error(`[${category}] ${message}`, data);
+    }
+  }
+  log(category, message, data) {
+    if (this.enabled) {
+      console.log(`[${category}] ${message}`, data);
+    }
+  }
+};
+
+// src/PhantomProvider.tsx
+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)(() => {
+    const redirectUrl = config.authOptions?.redirectUrl || `${config.scheme}://phantom-auth-callback`;
+    const embeddedConfig = {
+      apiBaseUrl: config.apiBaseUrl,
+      organizationId: config.organizationId,
+      authOptions: {
+        ...config.authOptions,
+        redirectUrl
+      },
+      embeddedWalletType: config.embeddedWalletType,
+      addressTypes: config.addressTypes,
+      solanaProvider: config.solanaProvider || "web3js"
+    };
+    const storage = new ExpoSecureStorage();
+    const authProvider = new ExpoAuthProvider();
+    const urlParamsAccessor = new ExpoURLParamsAccessor();
+    const logger = new ExpoLogger(config.debug);
+    const platform = {
+      storage,
+      authProvider,
+      urlParamsAccessor
+    };
+    return new import_embedded_provider_core.EmbeddedProvider(embeddedConfig, platform, logger);
+  }, [config]);
+  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
+  const [addresses, setAddresses] = (0, import_react.useState)([]);
+  const [walletId, setWalletId] = (0, import_react.useState)(null);
+  const [error, setError] = (0, import_react.useState)(null);
+  const updateConnectionState = (0, import_react.useCallback)(() => {
+    try {
+      const connected = sdk.isConnected();
+      setIsConnected(connected);
+      if (connected) {
+        const addrs = sdk.getAddresses();
+        setAddresses(addrs);
+      } else {
+        setAddresses([]);
+        setWalletId(null);
+      }
+    } catch (err) {
+      console.error("[PhantomProvider] Error updating connection state", err);
+      setError(err);
+    }
+  }, [sdk]);
+  (0, import_react.useEffect)(() => {
+    updateConnectionState();
+  }, [updateConnectionState]);
+  const value = {
+    sdk,
+    isConnected,
+    addresses,
+    walletId,
+    error,
+    updateConnectionState,
+    setWalletId
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PhantomContext.Provider, { value, children });
+}
+function usePhantom() {
+  const context = (0, import_react.useContext)(PhantomContext);
+  if (!context) {
+    throw new Error("usePhantom must be used within a PhantomProvider");
+  }
+  return context;
+}
+
+// src/hooks/useConnect.ts
+var import_react2 = require("react");
+function useConnect() {
+  const { sdk, updateConnectionState, setWalletId } = 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 (!sdk) {
+        throw new Error("SDK not initialized");
+      }
+      setIsConnecting(true);
+      setError(null);
+      try {
+        const result = await sdk.connect(options);
+        if (result.status === "completed") {
+          if (result.walletId) {
+            setWalletId(result.walletId);
+          }
+          updateConnectionState();
+        }
+        return result;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsConnecting(false);
+      }
+    },
+    [sdk, updateConnectionState, setWalletId]
+  );
+  return {
+    connect,
+    isConnecting,
+    error
+  };
+}
+
+// src/hooks/useDisconnect.ts
+var import_react3 = require("react");
+function useDisconnect() {
+  const { sdk, 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) {
+      throw new Error("SDK not initialized");
+    }
+    setIsDisconnecting(true);
+    setError(null);
+    try {
+      await sdk.disconnect();
+      updateConnectionState();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsDisconnecting(false);
+    }
+  }, [sdk, updateConnectionState]);
+  return {
+    disconnect,
+    isDisconnecting,
+    error
+  };
+}
+
+// src/hooks/useAccounts.ts
+function useAccounts() {
+  const { addresses, isConnected, walletId, error } = usePhantom();
+  return {
+    addresses,
+    isConnected,
+    walletId,
+    error
+  };
+}
+
+// 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");
+      }
+      setIsSigning(true);
+      setError(null);
+      try {
+        const signature = await sdk.signMessage(params);
+        return signature;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } 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");
+      }
+      setIsSigning(true);
+      setError(null);
+      try {
+        const result = await sdk.signAndSendTransaction(params);
+        return result;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsSigning(false);
+      }
+    },
+    [sdk]
+  );
+  return {
+    signAndSendTransaction,
+    isSigning,
+    error
+  };
+}
+
+// src/index.ts
+var import_client = require("@phantom/client");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddressType,
+  NetworkId,
+  PhantomProvider,
+  useAccounts,
+  useConnect,
+  useDisconnect,
+  usePhantom,
+  useSignAndSendTransaction,
+  useSignMessage
+});