@phantom/react-native-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,434 @@
+// src/PhantomProvider.tsx
+import { createContext, useContext, useState, useEffect, useCallback, useMemo } from "react";
+import { EmbeddedProvider } from "@phantom/embedded-provider-core";
+
+// src/providers/embedded/storage.ts
+import * as SecureStore from "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
+import * as WebBrowser from "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
+import { Linking } from "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 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 = 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
+import { jsx } from "react/jsx-runtime";
+var PhantomContext = createContext(void 0);
+function PhantomProvider({ children, config }) {
+  const sdk = 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 EmbeddedProvider(embeddedConfig, platform, logger);
+  }, [config]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [addresses, setAddresses] = useState([]);
+  const [walletId, setWalletId] = useState(null);
+  const [error, setError] = useState(null);
+  const updateConnectionState = 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]);
+  useEffect(() => {
+    updateConnectionState();
+  }, [updateConnectionState]);
+  const value = {
+    sdk,
+    isConnected,
+    addresses,
+    walletId,
+    error,
+    updateConnectionState,
+    setWalletId
+  };
+  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 { useState as useState2, useCallback as useCallback2 } from "react";
+function useConnect() {
+  const { sdk, updateConnectionState, setWalletId } = usePhantom();
+  const [isConnecting, setIsConnecting] = useState2(false);
+  const [error, setError] = useState2(null);
+  const connect = useCallback2(
+    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
+import { useState as useState3, useCallback as useCallback3 } from "react";
+function useDisconnect() {
+  const { sdk, updateConnectionState } = usePhantom();
+  const [isDisconnecting, setIsDisconnecting] = useState3(false);
+  const [error, setError] = useState3(null);
+  const disconnect = useCallback3(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
+import { useState as useState4, useCallback as useCallback4 } from "react";
+function useSignMessage() {
+  const { sdk } = usePhantom();
+  const [isSigning, setIsSigning] = useState4(false);
+  const [error, setError] = useState4(null);
+  const signMessage = useCallback4(
+    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
+import { useState as useState5, useCallback as useCallback5 } from "react";
+function useSignAndSendTransaction() {
+  const { sdk } = usePhantom();
+  const [isSigning, setIsSigning] = useState5(false);
+  const [error, setError] = useState5(null);
+  const signAndSendTransaction = useCallback5(
+    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
+import { AddressType, NetworkId } from "@phantom/client";
+export {
+  AddressType,
+  NetworkId,
+  PhantomProvider,
+  useAccounts,
+  useConnect,
+  useDisconnect,
+  usePhantom,
+  useSignAndSendTransaction,
+  useSignMessage
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@phantom/react-native-sdk",
+  "version": "0.1.0",
+  "description": "Phantom Wallet SDK for React Native and Expo applications",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "?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",
+    "build": "rimraf ./dist && tsup",
+    "dev": "rimraf ./dist && tsup --watch",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "tsc --noEmit && eslint --cache . --ext .ts,.tsx",
+    "check-types": "tsc --noEmit",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
+  },
+  "keywords": [
+    "phantom",
+    "wallet",
+    "react-native",
+    "expo",
+    "solana",
+    "ethereum",
+    "crypto",
+    "web3"
+  ],
+  "author": "Phantom",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phantom/wallet-sdk.git",
+    "directory": "packages/react-native-sdk"
+  },
+  "dependencies": {
+    "@phantom/client": "^0.1.3",
+    "@phantom/embedded-provider-core": "^0.1.1"
+  },
+  "peerDependencies": {
+    "expo": ">=53.0.0",
+    "expo-auth-session": ">=5.0.0",
+    "expo-secure-store": ">=12.0.0",
+    "expo-web-browser": ">=12.0.0",
+    "react": ">=19.0.0",
+    "react-native": ">=0.79.0",
+    "react-native-get-random-values": ">=1.8.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/react": "~19.0.10",
+    "@types/react-native": "^0.72.0",
+    "eslint": "8.53.0",
+    "eslint-define-config": "^1.24.1",
+    "eslint-plugin-react": "^7.33.0",
+    "eslint-plugin-react-native": "^4.1.0",
+    "expo": "^53.0.20",
+    "expo-auth-session": "^6.2.1",
+    "expo-secure-store": "^14.2.3",
+    "expo-web-browser": "^14.2.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "prettier": "^3.5.2",
+    "react": "19.1.1",
+    "react-native": "0.79.5",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29",
+    "tsup": "^6.7.0",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "directory": "_release/package"
+  }
+}