@sip-protocol/react 0.1.0

package/dist/index.js

@@ -0,0 +1,389 @@
+"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, {
+  SIPProvider: () => SIPProvider,
+  usePrivateSwap: () => usePrivateSwap,
+  useSIP: () => useSIP,
+  useStealthAddress: () => useStealthAddress,
+  useViewingKey: () => useViewingKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/sip-provider.tsx
+var import_react = __toESM(require("react"));
+var import_sdk = require("@sip-protocol/sdk");
+var SIPContext = (0, import_react.createContext)(void 0);
+function SIPProvider({ config, children }) {
+  const client = (0, import_react.useMemo)(() => new import_sdk.SIP(config), [config]);
+  const value = (0, import_react.useMemo)(() => ({ client, config }), [client, config]);
+  return /* @__PURE__ */ import_react.default.createElement(SIPContext.Provider, { value }, children);
+}
+function useSIPContext() {
+  const context = (0, import_react.useContext)(SIPContext);
+  if (!context) {
+    throw new Error("useSIPContext must be used within SIPProvider");
+  }
+  return context;
+}
+
+// src/hooks/use-sip.ts
+var import_react2 = require("react");
+var import_sdk2 = require("@sip-protocol/sdk");
+function useSIP() {
+  const [standaloneClient, setStandaloneClient] = (0, import_react2.useState)(null);
+  const [standaloneReady, setStandaloneReady] = (0, import_react2.useState)(false);
+  const [standaloneError, setStandaloneError] = (0, import_react2.useState)(null);
+  let providerContext;
+  try {
+    providerContext = useSIPContext();
+  } catch {
+    providerContext = null;
+  }
+  const standaloneInitialize = (0, import_react2.useCallback)(async (config) => {
+    if (standaloneClient && standaloneReady) {
+      console.warn("SIP client already initialized. Call will be ignored.");
+      return;
+    }
+    try {
+      setStandaloneError(null);
+      setStandaloneReady(false);
+      const newClient = new import_sdk2.SIP(config);
+      setStandaloneClient(newClient);
+      setStandaloneReady(true);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setStandaloneError(error);
+      setStandaloneReady(false);
+      throw error;
+    }
+  }, [standaloneClient, standaloneReady]);
+  if (providerContext) {
+    return {
+      client: providerContext.client,
+      isReady: true,
+      // Provider always provides ready client
+      error: null,
+      // Provider throws on error, doesn't expose it
+      initialize: async () => {
+        console.warn("initialize() called but SIPProvider is already providing a client. This call will be ignored.");
+      }
+    };
+  }
+  return {
+    client: standaloneClient,
+    isReady: standaloneReady,
+    error: standaloneError,
+    initialize: standaloneInitialize
+  };
+}
+
+// src/hooks/use-stealth-address.ts
+var import_react3 = require("react");
+var import_sdk3 = require("@sip-protocol/sdk");
+function useStealthAddress(chain) {
+  const [metaAddress, setMetaAddress] = (0, import_react3.useState)(null);
+  const [stealthAddress, setStealthAddress] = (0, import_react3.useState)(null);
+  const [isGenerating, setIsGenerating] = (0, import_react3.useState)(false);
+  (0, import_react3.useEffect)(() => {
+    let cancelled = false;
+    setIsGenerating(true);
+    const timer = setTimeout(() => {
+      if (cancelled) return;
+      try {
+        const isEd25519 = (0, import_sdk3.isEd25519Chain)(chain);
+        const metaAddressData = isEd25519 ? (0, import_sdk3.generateEd25519StealthMetaAddress)(chain) : (0, import_sdk3.generateStealthMetaAddress)(chain);
+        const encoded = (0, import_sdk3.encodeStealthMetaAddress)(metaAddressData.metaAddress);
+        if (cancelled) return;
+        setMetaAddress(encoded);
+        const stealthData = isEd25519 ? (0, import_sdk3.generateEd25519StealthAddress)(metaAddressData.metaAddress) : (0, import_sdk3.generateStealthAddress)(metaAddressData.metaAddress);
+        if (cancelled) return;
+        setStealthAddress(stealthData.stealthAddress.address);
+      } catch (error) {
+        console.error("Failed to generate stealth addresses:", error);
+        if (cancelled) return;
+        setMetaAddress(null);
+        setStealthAddress(null);
+      } finally {
+        if (!cancelled) {
+          setIsGenerating(false);
+        }
+      }
+    }, 0);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [chain]);
+  const regenerate = (0, import_react3.useCallback)(() => {
+    if (!metaAddress) {
+      return;
+    }
+    setIsGenerating(true);
+    setTimeout(() => {
+      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 isEd25519 = (0, import_sdk3.isEd25519Chain)(chain);
+        const stealthData = isEd25519 ? (0, import_sdk3.generateEd25519StealthAddress)(metaAddressObj) : (0, import_sdk3.generateStealthAddress)(metaAddressObj);
+        setStealthAddress(stealthData.stealthAddress.address);
+      } catch (error) {
+        console.error("Failed to regenerate stealth address:", error);
+      } finally {
+        setIsGenerating(false);
+      }
+    }, 0);
+  }, [metaAddress, chain]);
+  const copyToClipboard = (0, import_react3.useCallback)(async () => {
+    if (!stealthAddress) {
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(stealthAddress);
+    } catch (error) {
+      console.error("Failed to copy to clipboard:", error);
+      const textArea = document.createElement("textarea");
+      textArea.value = stealthAddress;
+      textArea.style.position = "fixed";
+      textArea.style.left = "-999999px";
+      document.body.appendChild(textArea);
+      textArea.select();
+      try {
+        document.execCommand("copy");
+      } catch (err) {
+        console.error("Fallback copy failed:", err);
+      } finally {
+        document.body.removeChild(textArea);
+      }
+    }
+  }, [stealthAddress]);
+  return {
+    metaAddress,
+    stealthAddress,
+    isGenerating,
+    regenerate,
+    copyToClipboard
+  };
+}
+
+// src/hooks/use-private-swap.ts
+var import_react4 = require("react");
+function usePrivateSwap() {
+  const { client: sip } = useSIP();
+  const [quote, setQuote] = (0, import_react4.useState)(null);
+  const [status, setStatus] = (0, import_react4.useState)("idle");
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const fetchQuote = (0, import_react4.useCallback)(async (params) => {
+    if (!sip) {
+      throw new Error("SIP client not initialized. Wrap your app with SIPProvider or call initialize().");
+    }
+    try {
+      setStatus("fetching_quote");
+      setIsLoading(true);
+      setError(null);
+      const intentParams = {
+        input: {
+          asset: {
+            chain: params.inputChain,
+            symbol: params.inputToken,
+            address: null,
+            decimals: 9
+            // Default, should be configurable
+          },
+          amount: BigInt(params.inputAmount)
+        },
+        output: {
+          asset: {
+            chain: params.outputChain,
+            symbol: params.outputToken,
+            address: null,
+            decimals: 18
+            // Default, should be configurable
+          },
+          minAmount: 0n,
+          maxSlippage: params.maxSlippage ?? 0.01
+        },
+        privacy: params.privacyLevel ?? "shielded"
+      };
+      const quotes = await sip.getQuotes(intentParams);
+      if (quotes.length === 0) {
+        throw new Error("No quotes available");
+      }
+      setQuote(quotes[0]);
+      setStatus("idle");
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch quote"));
+      setStatus("failed");
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sip]);
+  const swap = (0, import_react4.useCallback)(async (params) => {
+    if (!sip) {
+      throw new Error("SIP client not initialized. Wrap your app with SIPProvider or call initialize().");
+    }
+    try {
+      setStatus("pending");
+      setIsLoading(true);
+      setError(null);
+      const intentParams = {
+        input: {
+          asset: {
+            chain: params.input.chain,
+            symbol: params.input.token,
+            address: null,
+            decimals: 9
+            // Default, should be configurable
+          },
+          amount: params.input.amount
+        },
+        output: {
+          asset: {
+            chain: params.output.chain,
+            symbol: params.output.token,
+            address: null,
+            decimals: 18
+            // Default, should be configurable
+          },
+          minAmount: params.output.minAmount,
+          maxSlippage: params.maxSlippage ?? 0.01
+        },
+        privacy: params.privacyLevel
+      };
+      const intent = await sip.createIntent(intentParams);
+      let swapQuote = quote;
+      if (!swapQuote) {
+        const quotes = await sip.getQuotes(intentParams);
+        if (quotes.length === 0) {
+          throw new Error("No quotes available");
+        }
+        swapQuote = quotes[0];
+      }
+      setStatus("confirming");
+      const result = await sip.execute(intent, swapQuote);
+      setStatus("completed");
+      return {
+        txHash: result.txHash,
+        status: result.status,
+        outputAmount: result.outputAmount,
+        intentId: result.intentId
+      };
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Swap failed"));
+      setStatus("failed");
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sip, quote]);
+  const reset = (0, import_react4.useCallback)(() => {
+    setQuote(null);
+    setStatus("idle");
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    quote,
+    fetchQuote,
+    swap,
+    status,
+    isLoading,
+    error,
+    reset
+  };
+}
+
+// src/hooks/use-viewing-key.ts
+var import_react5 = require("react");
+var import_sdk4 = require("@sip-protocol/sdk");
+function useViewingKey() {
+  const [viewingKey, setViewingKey] = (0, import_react5.useState)(null);
+  const [sharedWith, setSharedWith] = (0, import_react5.useState)([]);
+  const generate = (0, import_react5.useCallback)((path) => {
+    const key = (0, import_sdk4.generateViewingKey)(path);
+    setViewingKey(key);
+    setSharedWith([]);
+    return key;
+  }, []);
+  const decrypt = (0, import_react5.useCallback)(
+    async (encrypted) => {
+      if (!viewingKey) {
+        throw new Error("No viewing key available. Call generate() first.");
+      }
+      return (0, import_sdk4.decryptWithViewing)(encrypted, viewingKey);
+    },
+    [viewingKey]
+  );
+  const share = (0, import_react5.useCallback)(
+    async (auditorId) => {
+      if (!viewingKey) {
+        throw new Error("No viewing key available. Call generate() first.");
+      }
+      const shareEntry = {
+        auditorId,
+        viewingKeyHash: viewingKey.hash,
+        sharedAt: Date.now()
+      };
+      setSharedWith((prev) => [...prev, shareEntry]);
+    },
+    [viewingKey]
+  );
+  return {
+    /** Current viewing key (null if not generated) */
+    viewingKey,
+    /** List of auditors who have been given access */
+    sharedWith,
+    /** Generate a new viewing key */
+    generate,
+    /** Decrypt encrypted transaction data */
+    decrypt,
+    /** Share viewing key with an auditor */
+    share
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SIPProvider,
+  usePrivateSwap,
+  useSIP,
+  useStealthAddress,
+  useViewingKey
+});