@cofhe/react 0.0.0-beta-20251106215647

package/dist/index.cjs

@@ -0,0 +1,619 @@
+"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, {
+  CofheProvider: () => CofheProvider,
+  FheTypesList: () => FheTypesList,
+  FnxEncryptInput: () => FnxEncryptInput,
+  encryptedValueToString: () => encryptedValueToString,
+  fheTypeToString: () => fheTypeToString,
+  useCofheContext: () => useCofheContext,
+  useEncryptInput: () => useEncryptInput
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/CofheProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var CofheContext = (0, import_react.createContext)(void 0);
+function CofheProvider({ children, client: providedClient, config }) {
+  const [client, setClient] = (0, import_react.useState)(providedClient || null);
+  const [isInitialized, setIsInitialized] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (providedClient) {
+      setClient(providedClient);
+      setIsInitialized(true);
+      return;
+    }
+    if (config) {
+      try {
+        setIsInitialized(true);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to initialize CoFHE client"));
+      }
+    }
+  }, [providedClient, config]);
+  const contextValue = {
+    client,
+    isInitialized,
+    error
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CofheContext.Provider, { value: contextValue, children });
+}
+function useCofheContext() {
+  const context = (0, import_react.useContext)(CofheContext);
+  if (context === void 0) {
+    throw new Error("useCofheContext must be used within a CofheProvider");
+  }
+  return context;
+}
+
+// src/hooks/useEncryptInput.ts
+var import_react2 = require("react");
+var import_sdk = require("@cofhe/sdk");
+var STEP_CONFIG = {
+  "initTfhe": {
+    label: "Initializing TFHE...",
+    progress: 5
+  },
+  "fetchKeys": {
+    label: "Fetching FHE keys...",
+    progress: 20
+  },
+  "pack": {
+    label: "Packing data...",
+    progress: 40
+  },
+  "prove": {
+    label: "Generating proof...",
+    progress: 70
+  },
+  "verify": {
+    label: "Verifying...",
+    progress: 90
+  },
+  "done": {
+    label: "Encryption complete!",
+    progress: 100
+  }
+};
+function useEncryptInput() {
+  const { client } = useCofheContext();
+  const [isEncrypting, setIsEncrypting] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [encryptionStep, setEncryptionStep] = (0, import_react2.useState)(null);
+  const [encryptionProgress, setEncryptionProgress] = (0, import_react2.useState)(0);
+  const [encryptionProgressLabel, setEncryptionProgressLabel] = (0, import_react2.useState)("");
+  const onEncryptInput = (0, import_react2.useCallback)(async (type, value) => {
+    if (!client) {
+      throw new Error("CoFHE client not initialized");
+    }
+    setIsEncrypting(true);
+    setError(null);
+    try {
+      let convertedValue;
+      if (type === "bool") {
+        convertedValue = value.toLowerCase() === "true" || value === "1";
+      } else if (type === "address") {
+        convertedValue = value;
+      } else {
+        convertedValue = value.includes(".") ? parseFloat(value) : parseInt(value, 10);
+      }
+      let encryptableItem;
+      switch (type) {
+        case "bool":
+          encryptableItem = import_sdk.Encryptable.bool(convertedValue);
+          break;
+        case "uint8":
+          encryptableItem = import_sdk.Encryptable.uint8(BigInt(convertedValue));
+          break;
+        case "uint16":
+          encryptableItem = import_sdk.Encryptable.uint16(BigInt(convertedValue));
+          break;
+        case "uint32":
+          encryptableItem = import_sdk.Encryptable.uint32(BigInt(convertedValue));
+          break;
+        case "uint64":
+          encryptableItem = import_sdk.Encryptable.uint64(BigInt(convertedValue));
+          break;
+        case "uint128":
+          encryptableItem = import_sdk.Encryptable.uint128(BigInt(convertedValue));
+          break;
+        case "address":
+          encryptableItem = import_sdk.Encryptable.address(convertedValue);
+          break;
+        default:
+          encryptableItem = import_sdk.Encryptable.uint32(BigInt(convertedValue));
+      }
+      const encryptionBuilder = client.encryptInputs([encryptableItem]).setStepCallback((step, context) => {
+        const stepConfig = STEP_CONFIG[step];
+        if (stepConfig) {
+          setEncryptionStep(step);
+          setEncryptionProgress(stepConfig.progress);
+          setEncryptionProgressLabel(stepConfig.label);
+        }
+        if (step === "prove" && context?.isEnd) {
+          console.log("[Encryption] Worker Status:", {
+            useWorker: context.useWorker,
+            usedWorker: context.usedWorker,
+            workerFailedError: context.workerFailedError,
+            duration: context.duration + "ms"
+          });
+        }
+      });
+      const result = await encryptionBuilder.encrypt();
+      if (!result.success) {
+        throw result.error;
+      }
+      setEncryptionStep("done");
+      setEncryptionProgress(100);
+      setEncryptionProgressLabel("Encryption complete!");
+      setTimeout(() => {
+        setEncryptionStep(null);
+        setEncryptionProgress(0);
+        setEncryptionProgressLabel("");
+      }, 1e3);
+      setIsEncrypting(false);
+      return result.data[0];
+    } catch (err) {
+      setEncryptionStep(null);
+      setEncryptionProgress(0);
+      setEncryptionProgressLabel("");
+      setIsEncrypting(false);
+      const error2 = err instanceof Error ? err : new Error("Encryption failed");
+      setError(error2);
+      throw error2;
+    }
+  }, [client]);
+  return {
+    onEncryptInput,
+    isEncryptingInput: isEncrypting,
+    encryptionStep,
+    encryptionProgress,
+    encryptionProgressLabel,
+    inputEncryptionDisabled: isEncrypting || !!error
+  };
+}
+
+// src/components/FnxEncryptInput.tsx
+var import_react3 = require("react");
+
+// src/utils/cn.ts
+var cn = (...classes) => {
+  return classes.filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+};
+
+// src/utils/debounce.ts
+var debounce = (func, wait) => {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      func(...args);
+    }, wait);
+  };
+};
+
+// src/utils/utils.ts
+var FheTypesList = [
+  {
+    label: "Encrypted Bool",
+    value: "bool",
+    maxValue: BigInt(1),
+    // 0 or 1
+    description: "Boolean value (true/false)"
+  },
+  {
+    label: "Encrypted Uint8",
+    value: "uint8",
+    maxValue: BigInt(2 ** 8 - 1),
+    // 255
+    description: "8-bit unsigned integer (0 to 255)"
+  },
+  {
+    label: "Encrypted Uint16",
+    value: "uint16",
+    maxValue: BigInt(2 ** 16 - 1),
+    // 65,535
+    description: "16-bit unsigned integer (0 to 65,535)"
+  },
+  {
+    label: "Encrypted Uint32",
+    value: "uint32",
+    maxValue: BigInt(2 ** 32 - 1),
+    // 4,294,967,295
+    description: "32-bit unsigned integer (0 to 4,294,967,295)"
+  },
+  {
+    label: "Encrypted Uint64",
+    value: "uint64",
+    maxValue: BigInt(2 ** 64 - 1),
+    // 18,446,744,073,709,551,615
+    description: "64-bit unsigned integer (0 to 18,446,744,073,709,551,615)"
+  },
+  {
+    label: "Encrypted Uint128",
+    value: "uint128",
+    maxValue: BigInt(2 ** 128 - 1),
+    // Very large number
+    description: "128-bit unsigned integer"
+  },
+  {
+    label: "Encrypted Address",
+    value: "address",
+    maxValue: null,
+    // Address validation is different
+    description: "Ethereum address (0x...)"
+  }
+];
+
+// src/components/FnxEncryptInput.tsx
+var import_Security = __toESM(require("@mui/icons-material/Security"), 1);
+var import_KeyboardArrowDown = __toESM(require("@mui/icons-material/KeyboardArrowDown"), 1);
+var import_ContentCopy = __toESM(require("@mui/icons-material/ContentCopy"), 1);
+var import_Check = __toESM(require("@mui/icons-material/Check"), 1);
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var FnxEncryptInput = ({
+  className,
+  testId,
+  placeholder = "Enter number or address...",
+  initialValue = "",
+  options = FheTypesList,
+  size = "md",
+  hasError = false,
+  errorMessage,
+  disabled = false,
+  showProgressBar = false,
+  debounceMs = 300,
+  onTextChange,
+  onTypeChange,
+  onEncryptStart,
+  onEncryptProgress,
+  onEncryptComplete,
+  onEncryptError
+}) => {
+  const [textValue, setTextValue] = (0, import_react3.useState)(initialValue);
+  const [selectedType, setSelectedType] = (0, import_react3.useState)(options[0]?.value || "uint32");
+  const [isDropdownOpen, setIsDropdownOpen] = (0, import_react3.useState)(false);
+  const [showProgress, setShowProgress] = (0, import_react3.useState)(false);
+  const [encryptedResult, setEncryptedResult] = (0, import_react3.useState)(null);
+  const [copySuccess, setCopySuccess] = (0, import_react3.useState)(false);
+  const dropdownRef = (0, import_react3.useRef)(null);
+  const { onEncryptInput, isEncryptingInput, encryptionStep, encryptionProgress, encryptionProgressLabel } = useEncryptInput();
+  const debouncedValidation = (0, import_react3.useRef)(
+    debounce((value) => {
+      console.log("Debounced validation for:", value);
+    }, debounceMs)
+  ).current;
+  (0, import_react3.useEffect)(() => {
+    if (showProgressBar && isEncryptingInput) {
+      setShowProgress(true);
+    } else if (!isEncryptingInput) {
+      const timer = setTimeout(() => setShowProgress(false), 500);
+      return () => clearTimeout(timer);
+    }
+  }, [showProgressBar, isEncryptingInput]);
+  (0, import_react3.useEffect)(() => {
+    if (isEncryptingInput && encryptionStep && encryptionProgress !== null && encryptionProgressLabel) {
+      onEncryptProgress?.({
+        step: encryptionStep.toString(),
+        progress: encryptionProgress,
+        label: encryptionProgressLabel
+      });
+    }
+  }, [encryptionStep, encryptionProgress, encryptionProgressLabel, isEncryptingInput, onEncryptProgress]);
+  (0, import_react3.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
+        setIsDropdownOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  const sizeClasses = {
+    sm: { input: "px-3 py-2 text-sm", dropdown: "px-2 py-1 text-xs", button: "px-3 py-1 text-sm" },
+    md: { input: "px-4 py-3 text-sm", dropdown: "px-3 py-2 text-sm", button: "px-4 py-2 text-sm" },
+    lg: { input: "px-5 py-4 text-base", dropdown: "px-4 py-3 text-base", button: "px-6 py-3 text-base" }
+  };
+  const inputContainerClasses = cn(
+    "relative flex items-center bg-white dark:bg-gray-800 border rounded-lg transition-colors",
+    "focus-within:ring-2 focus-within:ring-blue-500 focus-within:border-blue-500",
+    hasError ? "border-red-500 focus-within:ring-red-500 focus-within:border-red-500" : "border-gray-300 dark:border-gray-600",
+    (disabled || isEncryptingInput) && "bg-gray-100 dark:bg-gray-700 opacity-50",
+    className
+  );
+  const inputClasses = cn(
+    "flex-1 bg-transparent border-0 outline-none placeholder-gray-400 dark:placeholder-gray-500",
+    "text-gray-900 dark:text-white",
+    sizeClasses[size].input,
+    "pr-20",
+    // Make space for the dropdown button
+    (disabled || isEncryptingInput) && "cursor-not-allowed"
+  );
+  const dropdownButtonClasses = cn(
+    "absolute right-0 top-0 bottom-0",
+    "flex items-center gap-1 px-2 rounded-r-md border-l border-gray-300 dark:border-gray-600",
+    "bg-gray-100 dark:bg-gray-700 hover:bg-gray-200 dark:hover:bg-gray-600",
+    "transition-colors duration-200 cursor-pointer",
+    "text-xs font-medium text-gray-700 dark:text-gray-300",
+    (disabled || isEncryptingInput) && "cursor-not-allowed opacity-50",
+    isDropdownOpen && "bg-gray-200 dark:bg-gray-600"
+  );
+  const dropdownItemClasses = (isSelected, isCompatible) => cn(
+    "px-3 py-2 text-sm transition-colors",
+    isCompatible ? "cursor-pointer hover:bg-blue-50 dark:hover:bg-blue-900/30 hover:text-blue-700 dark:hover:text-blue-300" : "cursor-not-allowed opacity-50 bg-gray-50 dark:bg-gray-700",
+    isSelected && isCompatible ? "bg-blue-100 dark:bg-blue-900/50 text-blue-700 dark:text-blue-300 font-medium" : isCompatible ? "text-gray-700 dark:text-gray-300" : "text-gray-400 dark:text-gray-500"
+  );
+  const progressVariantClasses = {
+    primary: "bg-blue-600 dark:bg-blue-500",
+    success: "bg-green-600 dark:bg-green-500",
+    warning: "bg-yellow-600 dark:bg-yellow-500",
+    error: "bg-red-600 dark:bg-red-500"
+  };
+  const progressContainerClasses = cn(
+    "w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1 overflow-hidden",
+    // Debug: Add border to see container
+    "border"
+  );
+  const progressBarClasses = (variant = "primary") => cn(
+    "h-full transition-all duration-300 ease-out rounded-full",
+    progressVariantClasses[variant]
+  );
+  const isTypeCompatible = (typeValue, inputValue) => {
+    if (!inputValue.trim()) return true;
+    const typeInfo = FheTypesList.find((type) => type.value === typeValue);
+    if (!typeInfo) return false;
+    if (typeValue === "bool") {
+      const lowerValue = inputValue.toLowerCase();
+      return lowerValue === "true" || lowerValue === "false" || lowerValue === "0" || lowerValue === "1";
+    }
+    if (typeValue === "address") {
+      if (!inputValue.startsWith("0x")) return false;
+      const addressPart = inputValue.slice(2);
+      if (addressPart.length !== 40) return false;
+      const hexRegex = /^[a-fA-F0-9]+$/;
+      if (!hexRegex.test(addressPart)) return false;
+      return true;
+    }
+    if (typeInfo.maxValue) {
+      try {
+        const numValue = BigInt(inputValue);
+        return numValue >= 0 && numValue <= typeInfo.maxValue;
+      } catch (error) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const handleTextChange = (e) => {
+    const value = e.target.value;
+    setTextValue(value);
+    onTextChange?.(value);
+    setEncryptedResult(null);
+    setCopySuccess(false);
+    debouncedValidation(value);
+  };
+  const handleCopyResult = async () => {
+    if (!encryptedResult || copySuccess) return;
+    try {
+      const textToCopy = JSON.stringify(encryptedResult, (key, value) => {
+        if (typeof value === "bigint") {
+          return value.toString();
+        }
+        return value;
+      }, 2);
+      await navigator.clipboard.writeText(textToCopy);
+      console.log("Copied to clipboard:", textToCopy);
+      setCopySuccess(true);
+      setTimeout(() => {
+        setCopySuccess(false);
+      }, 2e3);
+    } catch (error) {
+      console.error("Failed to copy to clipboard:", error);
+    }
+  };
+  const handleTypeSelect = async (type) => {
+    setSelectedType(type);
+    setIsDropdownOpen(false);
+    onTypeChange?.(type);
+    if (textValue.trim() !== "") {
+      try {
+        console.log("Auto-encrypting value:", textValue, "as type:", type);
+        onEncryptStart?.({ value: textValue, type });
+        (async () => {
+          try {
+            const encryptionResult = await onEncryptInput(type, textValue);
+            setEncryptedResult(encryptionResult);
+            const data = { value: textValue, encrypted: encryptionResult };
+            onEncryptComplete?.(data);
+          } catch (error) {
+            const errorMessage2 = error instanceof Error ? error.message : "Encryption failed";
+            console.error("Encryption failed:", error);
+            onEncryptError?.(errorMessage2);
+          }
+        })();
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : "Encryption setup failed";
+        console.error("Encryption setup failed:", error);
+        onEncryptError?.(errorMessage2);
+      }
+    }
+  };
+  const toggleDropdown = () => {
+    if (!disabled && !isEncryptingInput) {
+      setIsDropdownOpen(!isDropdownOpen);
+    }
+  };
+  const ShieldIcon = () => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Security.default, { sx: { fontSize: 14 } });
+  const ChevronDownIcon = () => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_KeyboardArrowDown.default, { sx: { fontSize: 14 } });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "w-full", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex items-start gap-3", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex-1", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: inputContainerClasses, "data-testid": testId, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "input",
+          {
+            type: "text",
+            className: inputClasses,
+            placeholder,
+            value: textValue,
+            onChange: handleTextChange,
+            disabled: disabled || isEncryptingInput,
+            "data-testid": testId ? `${testId}-input` : "fnx-encrypt-input"
+          }
+        ),
+        (isEncryptingInput || encryptedResult) && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "absolute right-16 top-1/2 transform -translate-y-1/2", children: isEncryptingInput ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "bg-blue-500 px-2 py-1 text-xs text-white rounded animate-pulse", children: "Encrypting..." }) : encryptedResult ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            onClick: handleCopyResult,
+            disabled: copySuccess,
+            className: `px-2 py-1 text-xs text-white rounded flex items-center gap-1 transition-all duration-300 ${copySuccess ? "bg-green-600 cursor-default" : "bg-green-500 hover:bg-green-600"}`,
+            title: copySuccess ? "Copied to clipboard!" : "Copy encrypted result to clipboard",
+            children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+              copySuccess ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Check.default, { sx: { fontSize: 12 } }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ContentCopy.default, { sx: { fontSize: 12 } }),
+              "Copy"
+            ] })
+          }
+        ) : null }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "cofhe-dropdown-container", ref: dropdownRef, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+            "button",
+            {
+              type: "button",
+              className: dropdownButtonClasses,
+              onClick: toggleDropdown,
+              disabled: disabled || isEncryptingInput,
+              "data-testid": testId ? `${testId}-type-selector` : "fnx-type-selector",
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ShieldIcon, {}),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ChevronDownIcon, {})
+              ]
+            }
+          ),
+          isDropdownOpen && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "cofhe-dropdown-menu", children: options.map((option) => {
+            const isCompatible = isTypeCompatible(option.value, textValue);
+            const isSelected = option.value === selectedType;
+            return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              "div",
+              {
+                className: dropdownItemClasses(isSelected, isCompatible),
+                onClick: () => isCompatible && handleTypeSelect(option.value),
+                "data-testid": `${testId ? `${testId}-` : ""}type-option-${option.value}`,
+                title: !isCompatible ? `Value "${textValue}" is not compatible with ${option.label}` : void 0,
+                children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "font-mono", children: option.label })
+              },
+              option.value
+            );
+          }) })
+        ] })
+      ] }),
+      showProgress && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+        "div",
+        {
+          className: "mt-3 overflow-hidden",
+          style: {
+            animation: isEncryptingInput ? "slideDownFadeIn 0.5s ease-out forwards" : "slideUpFadeOut 0.5s ease-out forwards"
+          },
+          "data-testid": testId ? `${testId}-progress` : "fnx-encrypt-progress",
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "flex justify-between items-center mb-1", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "text-sm font-medium text-gray-700 dark:text-gray-300", children: encryptionProgressLabel || "Processing..." }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "text-sm text-gray-500 dark:text-gray-400", children: [
+                encryptionProgress || 0,
+                "%"
+              ] })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: progressContainerClasses, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              "div",
+              {
+                className: progressBarClasses("primary"),
+                style: {
+                  width: `${Math.min(100, Math.max(0, encryptionProgress || 0))}%`,
+                  transition: "width 0.3s ease-out"
+                },
+                "data-testid": testId ? `${testId}-progress-bar` : "fnx-encrypt-progress-bar"
+              }
+            ) })
+          ]
+        }
+      )
+    ] }) }),
+    hasError && errorMessage && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "p",
+      {
+        className: "mt-2 text-sm text-red-600 dark:text-red-400",
+        "data-testid": testId ? `${testId}-error` : "fnx-encrypt-error",
+        children: errorMessage
+      }
+    )
+  ] });
+};
+
+// src/utils/logging.ts
+var fheTypeToString = (fheType) => {
+  switch (fheType) {
+    case "bool":
+      return "ebool";
+    case "uint8":
+      return "euint8";
+    case "uint16":
+      return "euint16";
+    case "uint32":
+      return "euint32";
+    case "uint64":
+      return "euint64";
+    case "uint128":
+      return "euint128";
+    case "address":
+      return "eaddress";
+    default:
+      return "unknown";
+  }
+};
+var encryptedValueToString = (fheType, handle) => {
+  const hashStr = handle.toString();
+  const truncated = hashStr.slice(0, 6) + ".." + hashStr.slice(hashStr.length - 6);
+  return `${fheTypeToString(fheType)}(${truncated})`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CofheProvider,
+  FheTypesList,
+  FnxEncryptInput,
+  encryptedValueToString,
+  fheTypeToString,
+  useCofheContext,
+  useEncryptInput
+});
+//# sourceMappingURL=index.cjs.map