@sip-protocol/react-native 0.1.0

package/dist/index.js

@@ -0,0 +1,612 @@
+"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 index_exports = {};
+__export(index_exports, {
+  SecureStorage: () => SecureStorage,
+  copyToClipboard: () => copyToClipboard,
+  getAssociatedTokenAddress: () => getAssociatedTokenAddress,
+  isClipboardAvailable: () => isClipboardAvailable,
+  readFromClipboard: () => readFromClipboard,
+  useScanPayments: () => useScanPayments,
+  useStealthAddress: () => useStealthAddress,
+  useStealthTransfer: () => useStealthTransfer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/use-stealth-address.ts
+var import_react = require("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] = (0, import_react.useState)(null);
+  const [stealthAddress, setStealthAddress] = (0, import_react.useState)(null);
+  const [spendingPrivateKey, setSpendingPrivateKey] = (0, import_react.useState)(null);
+  const [viewingPrivateKey, setViewingPrivateKey] = (0, import_react.useState)(null);
+  const [isGenerating, setIsGenerating] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.useCallback)(() => {
+    setError(null);
+  }, []);
+  return {
+    metaAddress,
+    stealthAddress,
+    spendingPrivateKey,
+    viewingPrivateKey,
+    isGenerating,
+    error,
+    regenerate,
+    copyToClipboard: copyToClipboard2,
+    saveToKeychain,
+    loadFromKeychain,
+    clearError
+  };
+}
+
+// src/hooks/use-stealth-transfer.ts
+var import_react2 = require("react");
+function useStealthTransfer(params) {
+  const { connection, wallet } = params;
+  const [status, setStatus] = (0, import_react2.useState)("idle");
+  const [error, setError] = (0, import_react2.useState)(null);
+  const transfer = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(() => {
+    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
+var import_react3 = require("react");
+function useScanPayments(params) {
+  const { connection } = params;
+  const [payments, setPayments] = (0, import_react3.useState)([]);
+  const [status, setStatus] = (0, import_react3.useState)("idle");
+  const [error, setError] = (0, import_react3.useState)(null);
+  const scanningRef = (0, import_react3.useRef)(false);
+  const scan = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(() => {
+    setPayments([]);
+    setError(null);
+    setStatus("idle");
+  }, []);
+  return {
+    payments,
+    status,
+    error,
+    isScanning: status === "scanning",
+    scan,
+    claim,
+    claimAll,
+    clear
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecureStorage,
+  copyToClipboard,
+  getAssociatedTokenAddress,
+  isClipboardAvailable,
+  readFromClipboard,
+  useScanPayments,
+  useStealthAddress,
+  useStealthTransfer
+});