@sip-protocol/react-native 0.1.0

package/dist/index.mjs

@@ -0,0 +1,575 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hooks/use-stealth-address.ts
+import { useState, useEffect, useCallback } from "react";
+
+// src/utils/clipboard.ts
+var Clipboard = null;
+try {
+  Clipboard = __require("@react-native-clipboard/clipboard").default;
+} catch {
+}
+async function copyToClipboard(text) {
+  if (!Clipboard) {
+    console.warn(
+      "@react-native-clipboard/clipboard is not available. Install it for clipboard functionality."
+    );
+    return false;
+  }
+  try {
+    Clipboard.setString(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFromClipboard() {
+  if (!Clipboard) {
+    console.warn(
+      "@react-native-clipboard/clipboard is not available. Install it for clipboard functionality."
+    );
+    return "";
+  }
+  try {
+    return await Clipboard.getString();
+  } catch {
+    return "";
+  }
+}
+function isClipboardAvailable() {
+  return !!Clipboard;
+}
+
+// src/storage/secure-storage.ts
+var DEFAULT_SERVICE = "com.sip-protocol.keys";
+var KEY_PREFIXES = {
+  spending: "sip:spending:",
+  viewing: "sip:viewing:",
+  ephemeral: "sip:ephemeral:",
+  meta: "sip:meta:"
+};
+var memoryStorage = /* @__PURE__ */ new Map();
+var Keychain = null;
+try {
+  Keychain = __require("react-native-keychain");
+} catch {
+}
+function getBackend(options) {
+  if (options?.backend) {
+    return options.backend;
+  }
+  return Keychain ? "keychain" : "memory";
+}
+function buildKeyName(type, identifier) {
+  return `${KEY_PREFIXES[type]}${identifier}`;
+}
+async function setKey(type, identifier, value, options) {
+  const keyName = buildKeyName(type, identifier);
+  const backend = getBackend(options);
+  if (backend === "memory") {
+    memoryStorage.set(keyName, value);
+    return true;
+  }
+  if (!Keychain) {
+    throw new Error(
+      'react-native-keychain is required for secure storage. Install it or use backend: "memory" for testing.'
+    );
+  }
+  const service = options?.service ?? DEFAULT_SERVICE;
+  const keychainOptions = {
+    service,
+    accessible: mapAccessible(options?.accessible)
+  };
+  if (options?.requireBiometrics) {
+    keychainOptions.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_CURRENT_SET;
+    keychainOptions.authenticationType = Keychain.AUTHENTICATION_TYPE.BIOMETRICS;
+  }
+  const result = await Keychain.setGenericPassword(
+    keyName,
+    value,
+    keychainOptions
+  );
+  return !!result;
+}
+async function getKey(type, identifier, options) {
+  const keyName = buildKeyName(type, identifier);
+  const backend = getBackend(options);
+  if (backend === "memory") {
+    return memoryStorage.get(keyName) ?? null;
+  }
+  if (!Keychain) {
+    throw new Error(
+      'react-native-keychain is required for secure storage. Install it or use backend: "memory" for testing.'
+    );
+  }
+  const service = options?.service ?? DEFAULT_SERVICE;
+  const keychainOptions = {
+    service
+  };
+  if (options?.requireBiometrics) {
+    keychainOptions.authenticationPrompt = {
+      title: "Authenticate to access key",
+      subtitle: "SIP Protocol requires authentication",
+      description: "Use biometrics to unlock your private keys",
+      cancel: "Cancel"
+    };
+  }
+  const result = await Keychain.getGenericPassword(keychainOptions);
+  if (!result) {
+    return null;
+  }
+  if (result.username !== keyName) {
+    return null;
+  }
+  return result.password;
+}
+async function deleteKey(type, identifier, options) {
+  const keyName = buildKeyName(type, identifier);
+  const backend = getBackend(options);
+  if (backend === "memory") {
+    return memoryStorage.delete(keyName);
+  }
+  if (!Keychain) {
+    throw new Error("react-native-keychain is required for secure storage.");
+  }
+  const service = options?.service ?? DEFAULT_SERVICE;
+  return await Keychain.resetGenericPassword({ service });
+}
+async function clearAll(options) {
+  const backend = getBackend(options);
+  if (backend === "memory") {
+    memoryStorage.clear();
+    return true;
+  }
+  if (!Keychain) {
+    throw new Error("react-native-keychain is required for secure storage.");
+  }
+  const service = options?.service ?? DEFAULT_SERVICE;
+  return await Keychain.resetGenericPassword({ service });
+}
+function mapAccessible(level) {
+  if (!Keychain) return void 0;
+  switch (level) {
+    case "whenUnlocked":
+      return Keychain.ACCESSIBLE.WHEN_UNLOCKED;
+    case "afterFirstUnlock":
+      return Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK;
+    case "always":
+      return Keychain.ACCESSIBLE.ALWAYS;
+    default:
+      return Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY;
+  }
+}
+async function getSupportedBiometrics() {
+  if (!Keychain) {
+    return { available: false, biometryType: "None" };
+  }
+  const biometryType = await Keychain.getSupportedBiometryType();
+  if (!biometryType) {
+    return { available: false, biometryType: "None" };
+  }
+  return {
+    available: true,
+    biometryType
+  };
+}
+function isAvailable() {
+  return !!Keychain;
+}
+var SecureStorage = {
+  // Key operations
+  setKey,
+  getKey,
+  deleteKey,
+  clearAll,
+  // Convenience methods for viewing keys
+  setViewingKey: (identifier, key, options) => setKey("viewing", identifier, key, options),
+  getViewingKey: (identifier, options) => getKey("viewing", identifier, options),
+  deleteViewingKey: (identifier, options) => deleteKey("viewing", identifier, options),
+  // Convenience methods for spending keys
+  setSpendingKey: (identifier, key, options) => setKey("spending", identifier, key, options),
+  getSpendingKey: (identifier, options) => getKey("spending", identifier, options),
+  deleteSpendingKey: (identifier, options) => deleteKey("spending", identifier, options),
+  // Convenience methods for meta addresses
+  setMetaAddress: (identifier, meta, options) => setKey("meta", identifier, meta, options),
+  getMetaAddress: (identifier, options) => getKey("meta", identifier, options),
+  deleteMetaAddress: (identifier, options) => deleteKey("meta", identifier, options),
+  // Biometrics support
+  getSupportedBiometrics,
+  isAvailable
+};
+
+// src/hooks/use-stealth-address.ts
+function useStealthAddress(chain, options = {}) {
+  const { autoSave = false, requireBiometrics = false, walletId = "default" } = options;
+  const [metaAddress, setMetaAddress] = useState(null);
+  const [stealthAddress, setStealthAddress] = useState(null);
+  const [spendingPrivateKey, setSpendingPrivateKey] = useState(null);
+  const [viewingPrivateKey, setViewingPrivateKey] = useState(null);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    const generate = async () => {
+      setIsGenerating(true);
+      try {
+        const sdk = await import("@sip-protocol/sdk");
+        const generateStealthMetaAddress = sdk.generateStealthMetaAddress;
+        const metaAddressData = generateStealthMetaAddress(chain);
+        if (cancelled) return;
+        const encodeStealthMetaAddress = sdk.encodeStealthMetaAddress;
+        const encoded = encodeStealthMetaAddress(metaAddressData.metaAddress);
+        setMetaAddress(encoded);
+        setSpendingPrivateKey(metaAddressData.spendingPrivateKey);
+        setViewingPrivateKey(metaAddressData.viewingPrivateKey);
+        const generateStealthAddress = sdk.generateStealthAddress;
+        const stealthData = generateStealthAddress(metaAddressData.metaAddress);
+        if (cancelled) return;
+        setStealthAddress(stealthData.stealthAddress.address);
+        setError(null);
+        if (autoSave && !cancelled) {
+          await SecureStorage.setSpendingKey(walletId, metaAddressData.spendingPrivateKey, {
+            requireBiometrics
+          });
+          await SecureStorage.setViewingKey(walletId, metaAddressData.viewingPrivateKey, {
+            requireBiometrics
+          });
+          await SecureStorage.setMetaAddress(walletId, encoded, { requireBiometrics });
+        }
+      } catch (err) {
+        if (cancelled) return;
+        const error2 = err instanceof Error ? err : new Error("Failed to generate stealth addresses");
+        setError(error2);
+        setMetaAddress(null);
+        setStealthAddress(null);
+        setSpendingPrivateKey(null);
+        setViewingPrivateKey(null);
+      } finally {
+        if (!cancelled) {
+          setIsGenerating(false);
+        }
+      }
+    };
+    generate();
+    return () => {
+      cancelled = true;
+    };
+  }, [chain, autoSave, requireBiometrics, walletId]);
+  const regenerate = useCallback(() => {
+    if (!metaAddress) return;
+    setIsGenerating(true);
+    setTimeout(async () => {
+      try {
+        const parts = metaAddress.split(":");
+        if (parts.length < 4) {
+          throw new Error("Invalid meta-address format");
+        }
+        const [, chainId, spendingKey, viewingKey] = parts;
+        const metaAddressObj = {
+          chain: chainId,
+          spendingKey: spendingKey.startsWith("0x") ? spendingKey : `0x${spendingKey}`,
+          viewingKey: viewingKey.startsWith("0x") ? viewingKey : `0x${viewingKey}`
+        };
+        const sdk = await import("@sip-protocol/sdk");
+        const generateStealthAddress = sdk.generateStealthAddress;
+        const stealthData = generateStealthAddress(metaAddressObj);
+        setStealthAddress(stealthData.stealthAddress.address);
+        setError(null);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to regenerate stealth address");
+        setError(error2);
+      } finally {
+        setIsGenerating(false);
+      }
+    }, 0);
+  }, [metaAddress]);
+  const copyToClipboard2 = useCallback(async () => {
+    if (!stealthAddress) return false;
+    const success = await copyToClipboard(stealthAddress);
+    if (!success) {
+      setError(new Error("Failed to copy to clipboard"));
+    } else {
+      setError(null);
+    }
+    return success;
+  }, [stealthAddress]);
+  const saveToKeychain = useCallback(async () => {
+    if (!spendingPrivateKey || !viewingPrivateKey || !metaAddress) {
+      setError(new Error("No keys to save"));
+      return false;
+    }
+    try {
+      await SecureStorage.setSpendingKey(walletId, spendingPrivateKey, { requireBiometrics });
+      await SecureStorage.setViewingKey(walletId, viewingPrivateKey, { requireBiometrics });
+      await SecureStorage.setMetaAddress(walletId, metaAddress, { requireBiometrics });
+      setError(null);
+      return true;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to save to keychain");
+      setError(error2);
+      return false;
+    }
+  }, [spendingPrivateKey, viewingPrivateKey, metaAddress, walletId, requireBiometrics]);
+  const loadFromKeychain = useCallback(async () => {
+    try {
+      const storedMeta = await SecureStorage.getMetaAddress(walletId, { requireBiometrics });
+      const storedSpending = await SecureStorage.getSpendingKey(walletId, { requireBiometrics });
+      const storedViewing = await SecureStorage.getViewingKey(walletId, { requireBiometrics });
+      if (!storedMeta || !storedSpending || !storedViewing) {
+        setError(new Error("No keys found in keychain"));
+        return false;
+      }
+      setMetaAddress(storedMeta);
+      setSpendingPrivateKey(storedSpending);
+      setViewingPrivateKey(storedViewing);
+      setError(null);
+      return true;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to load from keychain");
+      setError(error2);
+      return false;
+    }
+  }, [walletId, requireBiometrics]);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    metaAddress,
+    stealthAddress,
+    spendingPrivateKey,
+    viewingPrivateKey,
+    isGenerating,
+    error,
+    regenerate,
+    copyToClipboard: copyToClipboard2,
+    saveToKeychain,
+    loadFromKeychain,
+    clearError
+  };
+}
+
+// src/hooks/use-stealth-transfer.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+function useStealthTransfer(params) {
+  const { connection, wallet } = params;
+  const [status, setStatus] = useState2("idle");
+  const [error, setError] = useState2(null);
+  const transfer = useCallback2(
+    async (transferParams) => {
+      const { recipientMetaAddress, amount, mint } = transferParams;
+      if (!wallet.publicKey) {
+        const err = new Error("Wallet not connected");
+        setError(err);
+        setStatus("error");
+        return { success: false, error: err };
+      }
+      try {
+        setStatus("preparing");
+        setError(null);
+        const sdk = await import("@sip-protocol/sdk");
+        if (!sdk.sendPrivateSPLTransfer) {
+          throw new Error(
+            "sendPrivateSPLTransfer not available. Install @sip-protocol/sdk with Solana support."
+          );
+        }
+        const sendPrivateSPLTransfer = sdk.sendPrivateSPLTransfer;
+        const { PublicKey } = await import("@solana/web3.js");
+        const { getAssociatedTokenAddress: getAssociatedTokenAddress2 } = await import("@solana/spl-token");
+        const mintPubkey = new PublicKey(mint);
+        const senderTokenAccount = await getAssociatedTokenAddress2(
+          mintPubkey,
+          new PublicKey(wallet.publicKey.toBase58())
+        );
+        setStatus("signing");
+        const result = await sendPrivateSPLTransfer({
+          connection,
+          sender: new PublicKey(wallet.publicKey.toBase58()),
+          senderTokenAccount,
+          recipientMetaAddress,
+          mint: mintPubkey,
+          amount,
+          signTransaction: wallet.signTransaction
+        });
+        setStatus("confirming");
+        const confirmation = await connection.confirmTransaction(
+          result.signature,
+          "confirmed"
+        );
+        if (confirmation.value.err) {
+          throw new Error(`Transaction failed: ${confirmation.value.err}`);
+        }
+        setStatus("success");
+        setError(null);
+        return {
+          success: true,
+          signature: result.signature,
+          stealthAddress: result.stealthAddress
+        };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Transfer failed");
+        setError(error2);
+        setStatus("error");
+        return { success: false, error: error2 };
+      }
+    },
+    [connection, wallet]
+  );
+  const reset = useCallback2(() => {
+    setStatus("idle");
+    setError(null);
+  }, []);
+  return {
+    transfer,
+    status,
+    error,
+    isLoading: status !== "idle" && status !== "success" && status !== "error",
+    reset
+  };
+}
+async function getAssociatedTokenAddress(mint, owner) {
+  const { PublicKey } = await import("@solana/web3.js");
+  const { getAssociatedTokenAddress: getATA } = await import("@solana/spl-token");
+  const ata = await getATA(new PublicKey(mint), new PublicKey(owner));
+  return ata.toBase58();
+}
+
+// src/hooks/use-scan-payments.ts
+import { useState as useState3, useCallback as useCallback3, useRef } from "react";
+function useScanPayments(params) {
+  const { connection } = params;
+  const [payments, setPayments] = useState3([]);
+  const [status, setStatus] = useState3("idle");
+  const [error, setError] = useState3(null);
+  const scanningRef = useRef(false);
+  const scan = useCallback3(
+    async (viewingPrivateKey, spendingPublicKey) => {
+      if (scanningRef.current) return;
+      scanningRef.current = true;
+      try {
+        setStatus("scanning");
+        setError(null);
+        const sdk = await import("@sip-protocol/sdk");
+        if (!sdk.scanForPayments) {
+          throw new Error(
+            "scanForPayments not available. Install @sip-protocol/sdk with Solana support."
+          );
+        }
+        const scanForPayments = sdk.scanForPayments;
+        const result = await scanForPayments({
+          connection,
+          viewingPrivateKey,
+          spendingPublicKey
+        });
+        const scannedPayments = result.map((p) => ({
+          signature: p.signature,
+          stealthAddress: p.stealthAddress,
+          ephemeralPublicKey: p.ephemeralPublicKey,
+          mint: p.mint,
+          amount: p.amount,
+          timestamp: p.timestamp ?? Date.now(),
+          claimed: false
+        }));
+        setPayments((prev) => {
+          const existingSigs = new Set(prev.map((p) => p.signature));
+          const newPayments = scannedPayments.filter((p) => !existingSigs.has(p.signature));
+          return [...prev, ...newPayments];
+        });
+        setStatus("idle");
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Scan failed");
+        setError(error2);
+        setStatus("error");
+      } finally {
+        scanningRef.current = false;
+      }
+    },
+    [connection]
+  );
+  const claim = useCallback3(
+    async (signature, spendingPrivateKey, destinationAddress) => {
+      try {
+        setStatus("claiming");
+        setError(null);
+        const payment = payments.find((p) => p.signature === signature);
+        if (!payment) {
+          throw new Error("Payment not found");
+        }
+        const sdk = await import("@sip-protocol/sdk");
+        const { PublicKey } = await import("@solana/web3.js");
+        if (!sdk.claimStealthPayment) {
+          throw new Error(
+            "claimStealthPayment not available. Install @sip-protocol/sdk with Solana support."
+          );
+        }
+        const claimStealthPayment = sdk.claimStealthPayment;
+        const result = await claimStealthPayment({
+          connection,
+          stealthAddress: payment.stealthAddress,
+          ephemeralPublicKey: payment.ephemeralPublicKey,
+          viewingPrivateKey: "",
+          // Not needed for claiming
+          spendingPrivateKey,
+          destinationAddress: new PublicKey(destinationAddress),
+          mint: new PublicKey(payment.mint)
+        });
+        setPayments(
+          (prev) => prev.map(
+            (p) => p.signature === signature ? { ...p, claimed: true } : p
+          )
+        );
+        setStatus("idle");
+        return result.signature;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Claim failed");
+        setError(error2);
+        setStatus("error");
+        return null;
+      }
+    },
+    [connection, payments]
+  );
+  const claimAll = useCallback3(
+    async (spendingPrivateKey, destinationAddress) => {
+      const unclaimedPayments = payments.filter((p) => !p.claimed);
+      const signatures = [];
+      for (const payment of unclaimedPayments) {
+        const sig = await claim(payment.signature, spendingPrivateKey, destinationAddress);
+        if (sig) {
+          signatures.push(sig);
+        }
+      }
+      return signatures;
+    },
+    [payments, claim]
+  );
+  const clear = useCallback3(() => {
+    setPayments([]);
+    setError(null);
+    setStatus("idle");
+  }, []);
+  return {
+    payments,
+    status,
+    error,
+    isScanning: status === "scanning",
+    scan,
+    claim,
+    claimAll,
+    clear
+  };
+}
+export {
+  SecureStorage,
+  copyToClipboard,
+  getAssociatedTokenAddress,
+  isClipboardAvailable,
+  readFromClipboard,
+  useScanPayments,
+  useStealthAddress,
+  useStealthTransfer
+};

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@sip-protocol/react-native",
+  "version": "0.1.0",
+  "description": "React Native SDK for Shielded Intents Protocol - privacy on iOS/Android",
+  "author": "SIP Protocol <hello@sip-protocol.org>",
+  "homepage": "https://sip-protocol.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sip-protocol/sip-protocol.git",
+    "directory": "packages/react-native"
+  },
+  "bugs": {
+    "url": "https://github.com/sip-protocol/sip-protocol/issues"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@sip-protocol/sdk": "0.7.3",
+    "@sip-protocol/types": "0.2.1"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-native": ">=0.71.0",
+    "@solana/web3.js": "^1.87.0",
+    "@solana/spl-token": "^0.4.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-keychain": {
+      "optional": true
+    },
+    "@react-native-clipboard/clipboard": {
+      "optional": true
+    },
+    "@solana/web3.js": {
+      "optional": true
+    },
+    "@solana/spl-token": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@solana/spl-token": "^0.4.0",
+    "@solana/web3.js": "^1.87.0",
+    "@testing-library/react-native": "^12.0.0",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.0",
+    "react": "^18.2.0",
+    "react-native": "^0.73.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.1.0"
+  },
+  "keywords": [
+    "sip",
+    "privacy",
+    "react-native",
+    "mobile",
+    "solana",
+    "ethereum",
+    "stealth-addresses",
+    "ios",
+    "android"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --external react --external react-native",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch --external react --external react-native",
+    "lint": "eslint --ext .ts,.tsx src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest"
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,30 @@
+/**
+ * React Native Hooks for SIP Protocol
+ *
+ * Mobile-optimized hooks with native storage and clipboard support.
+ */
+
+export {
+  useStealthAddress,
+  type UseStealthAddressOptions,
+  type UseStealthAddressReturn,
+} from './use-stealth-address'
+
+export {
+  useStealthTransfer,
+  type MobileWalletAdapter,
+  type TransferStatus,
+  type TransferParams,
+  type TransferResult,
+  type UseStealthTransferParams,
+  type UseStealthTransferReturn,
+  getAssociatedTokenAddress,
+} from './use-stealth-transfer'
+
+export {
+  useScanPayments,
+  type ScannedPayment,
+  type ScanStatus,
+  type UseScanPaymentsParams,
+  type UseScanPaymentsReturn,
+} from './use-scan-payments'