cilantro-react 0.1.0

package/dist/index.js

@@ -0,0 +1,2867 @@
+'use client';
+"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, {
+  AddSignerForm: () => AddSignerForm,
+  AuthForm: () => AuthForm,
+  AuthGuard: () => AuthGuard,
+  CilantroAuthProvider: () => CilantroAuthProvider,
+  CilantroProvider: () => CilantroProvider,
+  DelegatedKeySelector: () => DelegatedKeySelector,
+  LoginForm: () => LoginForm,
+  MessageSigningForm: () => MessageSigningForm,
+  RegisterForm: () => RegisterForm,
+  SIGNER_TYPES: () => SIGNER_TYPES,
+  SignerList: () => SignerList,
+  SignerSelector: () => SignerSelector,
+  TransactionSigningForm: () => TransactionSigningForm,
+  WalletProvider: () => WalletProvider,
+  WalletSelector: () => WalletSelector,
+  extractErrorMessage: () => extractErrorMessage,
+  extractResponseData: () => extractResponseData,
+  getSignerPublicKey: () => getSignerPublicKey,
+  getWalletData: () => getWalletData,
+  signAndSendTransactionWithSigner: () => signAndSendTransactionWithSigner,
+  signMessageWithSigner: () => signMessageWithSigner,
+  signTransactionWithSigner: () => signTransactionWithSigner,
+  useCilantroAuth: () => useCilantroAuth,
+  useMessageSigning: () => useMessageSigning,
+  useSignerSelection: () => useSignerSelection,
+  useSigners: () => useSigners,
+  useTransactionSigning: () => useTransactionSigning,
+  useWallets: () => useWallets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/providers/CilantroProvider.tsx
+var import_react3 = require("react");
+
+// src/providers/CilantroAuthProvider.tsx
+var import_react = require("react");
+var import_cilantro_sdk2 = require("cilantro-sdk");
+var import_auth = require("cilantro-sdk/auth");
+var import_user = require("cilantro-sdk/user");
+
+// src/core/auth.ts
+var import_cilantro_sdk = require("cilantro-sdk");
+var platformApiKey = "";
+var apiUrl;
+function setAuthConfig(config) {
+  platformApiKey = config.platformApiKey;
+  apiUrl = config.apiUrl;
+  const authPayload = {};
+  if (config.jwt) {
+    authPayload.jwt = config.jwt;
+  }
+  if (platformApiKey) {
+    authPayload.platformApiKey = platformApiKey;
+  }
+  if (apiUrl) {
+    authPayload.apiUrl = apiUrl;
+  }
+  (0, import_cilantro_sdk.setAuth)(authPayload);
+}
+function setSdkAuth(jwt) {
+  const authConfig = {};
+  if (jwt) {
+    authConfig.jwt = jwt;
+  }
+  if (platformApiKey) {
+    authConfig.platformApiKey = platformApiKey;
+  }
+  if (apiUrl) {
+    authConfig.apiUrl = apiUrl;
+  }
+  (0, import_cilantro_sdk.setAuth)(authConfig);
+}
+function getPlatformApiKey() {
+  return platformApiKey;
+}
+
+// src/core/types.ts
+function extractResponseData(response) {
+  if (!response) return null;
+  if (typeof response !== "object" || response === null) {
+    return response;
+  }
+  if ("data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) {
+        const authSigners = Array.isArray(dataObj.authenticationSigners) ? dataObj.authenticationSigners : [];
+        const onChainSigners = Array.isArray(dataObj.onChainSigners) ? dataObj.onChainSigners : [];
+        return [...authSigners, ...onChainSigners];
+      }
+    }
+    return data;
+  }
+  if ("success" in response && "data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) {
+        const authSigners = Array.isArray(dataObj.authenticationSigners) ? dataObj.authenticationSigners : [];
+        const onChainSigners = Array.isArray(dataObj.onChainSigners) ? dataObj.onChainSigners : [];
+        return [...authSigners, ...onChainSigners];
+      }
+    }
+    return data;
+  }
+  if ("authenticationSigners" in response || "onChainSigners" in response) {
+    const responseObj = response;
+    const authSigners = Array.isArray(responseObj.authenticationSigners) ? responseObj.authenticationSigners : [];
+    const onChainSigners = Array.isArray(responseObj.onChainSigners) ? responseObj.onChainSigners : [];
+    return [...authSigners, ...onChainSigners];
+  }
+  return response;
+}
+function extractOnChainSigners(response) {
+  if (!response || typeof response !== "object" || response === null) return [];
+  let signersObj = null;
+  if ("data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) signersObj = dataObj;
+    }
+  }
+  if (!signersObj && "success" in response && "data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) signersObj = dataObj;
+    }
+  }
+  if (!signersObj && ("authenticationSigners" in response || "onChainSigners" in response)) {
+    signersObj = response;
+  }
+  if (signersObj) {
+    return Array.isArray(signersObj.onChainSigners) ? signersObj.onChainSigners : [];
+  }
+  if (Array.isArray(response)) return response;
+  return [];
+}
+function extractAuthenticationSigners(response) {
+  if (!response || typeof response !== "object" || response === null) return [];
+  let signersObj = null;
+  if ("data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) signersObj = dataObj;
+    }
+  }
+  if (!signersObj && "success" in response && "data" in response) {
+    const data = response.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const dataObj = data;
+      if ("authenticationSigners" in dataObj || "onChainSigners" in dataObj) signersObj = dataObj;
+    }
+  }
+  if (!signersObj && ("authenticationSigners" in response || "onChainSigners" in response)) {
+    signersObj = response;
+  }
+  if (signersObj) {
+    return Array.isArray(signersObj.authenticationSigners) ? signersObj.authenticationSigners : [];
+  }
+  return [];
+}
+function isErrorWithResponse(error) {
+  return typeof error === "object" && error !== null && "response" in error;
+}
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+
+// src/core/error-utils.ts
+function extractErrorMessage(error) {
+  if (!error) return "An unknown error occurred";
+  if (error instanceof Error) return error.message;
+  if (isErrorWithResponse(error)) {
+    if (error.response?.data?.message) return String(error.response.data.message);
+    if (error.response?.data?.error) return String(error.response.data.error);
+  }
+  if (isErrorWithMessage(error)) return String(error.message);
+  if (typeof error === "object" && error !== null && "error" in error) {
+    return String(error.error);
+  }
+  return String(error);
+}
+
+// src/providers/CilantroAuthProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AuthContext = (0, import_react.createContext)(void 0);
+var DEFAULT_JWT_STORAGE_KEY = "cilantro_jwt";
+function CilantroAuthProvider({
+  children,
+  platformApiKey: platformApiKey2,
+  apiUrl: apiUrl2,
+  jwtStorageKey = DEFAULT_JWT_STORAGE_KEY,
+  onLoginSuccess,
+  onLogout,
+  onRegisterSuccess
+}) {
+  const [user, setUser] = (0, import_react.useState)(null);
+  const [token, setToken] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  (0, import_react.useEffect)(() => {
+    setAuthConfig({ platformApiKey: platformApiKey2, apiUrl: apiUrl2 });
+    setSdkAuth(null);
+    const storedToken = typeof window !== "undefined" ? localStorage.getItem(jwtStorageKey) : null;
+    if (storedToken) {
+      setToken(storedToken);
+      setSdkAuth(storedToken);
+      try {
+        const payload = JSON.parse(atob(storedToken.split(".")[1]));
+        setUser({
+          username: payload.username,
+          email: payload.email,
+          userType: payload.userType
+        });
+      } catch {
+      }
+    }
+    setIsLoading(false);
+  }, [platformApiKey2, apiUrl2, jwtStorageKey]);
+  const login = async (usernameOrEmail, password) => {
+    try {
+      const result = await (0, import_auth.login)({ usernameOrEmail, password });
+      const responseData = extractResponseData(result);
+      if (!responseData?.jwt) throw new Error("No JWT token received from server");
+      const jwt = responseData.jwt;
+      const userType = responseData.userType;
+      setToken(jwt);
+      setSdkAuth(jwt);
+      if (typeof window !== "undefined") {
+        localStorage.setItem(jwtStorageKey, jwt);
+        document.cookie = `cilantro_jwt=${jwt}; path=/; max-age=${60 * 60 * 24 * 7}`;
+      }
+      try {
+        const payload = JSON.parse(atob(jwt.split(".")[1]));
+        setUser({
+          username: payload.username,
+          email: payload.email,
+          userType: userType ?? payload.userType
+        });
+      } catch {
+        setUser({ userType });
+      }
+      onLoginSuccess?.();
+    } catch (error) {
+      throw new Error(extractErrorMessage(error));
+    }
+  };
+  const register = async (username, email, password, isActive = true) => {
+    try {
+      setSdkAuth(null);
+      const platformKey = getPlatformApiKey();
+      const userData = { username, email, password, isActive };
+      if (platformKey) userData.platformApiKey = platformKey;
+      await (0, import_user.create)(userData);
+      await login(username, password);
+      onRegisterSuccess?.();
+    } catch (error) {
+      throw new Error(extractErrorMessage(error));
+    }
+  };
+  const logout = () => {
+    setUser(null);
+    setToken(null);
+    (0, import_cilantro_sdk2.clearAuth)();
+    if (typeof window !== "undefined") {
+      localStorage.removeItem(jwtStorageKey);
+      const keys = Object.keys(localStorage);
+      keys.forEach((key) => {
+        if (key.startsWith("delegated-key-")) localStorage.removeItem(key);
+      });
+      document.cookie = "cilantro_jwt=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+    }
+    setSdkAuth(null);
+    onLogout?.();
+  };
+  const value = {
+    user,
+    token,
+    isAuthenticated: !!token,
+    login,
+    register,
+    logout,
+    isLoading
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value, children });
+}
+function useCilantroAuth() {
+  const context = (0, import_react.useContext)(AuthContext);
+  if (context === void 0) {
+    throw new Error("useCilantroAuth must be used within a CilantroAuthProvider");
+  }
+  return context;
+}
+
+// src/providers/WalletProvider.tsx
+var import_react2 = require("react");
+var import_wallet = require("cilantro-sdk/wallet");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var WalletContext = (0, import_react2.createContext)(void 0);
+var DEFAULT_STORAGE_KEY = "cilantro_selected_wallet_id";
+function WalletProvider({ children, storageKey = DEFAULT_STORAGE_KEY }) {
+  const { token } = useCilantroAuth();
+  const [wallets, setWallets] = (0, import_react2.useState)([]);
+  const [selectedWallet, setSelectedWallet] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
+  (0, import_react2.useEffect)(() => {
+    if (token) {
+      loadWallets();
+    } else {
+      setWallets([]);
+      setSelectedWallet(null);
+      setIsLoading(false);
+    }
+  }, [token]);
+  (0, import_react2.useEffect)(() => {
+    if (wallets.length > 0 && !selectedWallet) {
+      const storedWalletId = typeof window !== "undefined" ? localStorage.getItem(storageKey) : null;
+      if (storedWalletId) {
+        const wallet = wallets.find((w) => w.id === storedWalletId || w.walletId === storedWalletId);
+        if (wallet) {
+          setSelectedWallet(wallet);
+        } else {
+          setSelectedWallet(wallets[0]);
+          if (typeof window !== "undefined") localStorage.setItem(storageKey, wallets[0].id);
+        }
+      } else {
+        if (wallets.length > 0) {
+          setSelectedWallet(wallets[0]);
+          if (typeof window !== "undefined") localStorage.setItem(storageKey, wallets[0].id);
+        }
+      }
+    } else if (wallets.length === 0) {
+      setSelectedWallet(null);
+      if (typeof window !== "undefined") localStorage.removeItem(storageKey);
+    }
+  }, [wallets, storageKey]);
+  const loadWallets = async () => {
+    try {
+      setIsLoading(true);
+      if (token) setSdkAuth(token);
+      const result = await (0, import_wallet.findAll)();
+      const walletsList = extractResponseData(result) ?? [];
+      const formattedWallets = Array.isArray(walletsList) ? walletsList.map((wallet) => {
+        const w = wallet;
+        return {
+          id: String(w.walletId ?? w.id ?? ""),
+          walletId: String(w.walletId ?? w.id ?? ""),
+          walletName: w.walletName ?? "",
+          address: w.walletAddress ?? w.address ?? "",
+          walletAddress: w.walletAddress ?? w.address ?? "",
+          chain: w.chain ?? "solana",
+          active: w.active !== false,
+          ...w
+        };
+      }) : [];
+      setWallets(formattedWallets);
+    } catch (error) {
+      console.error("Failed to load wallets:", error);
+      setWallets([]);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const selectWallet = (walletId) => {
+    const wallet = wallets.find((w) => w.id === walletId || w.walletId === walletId);
+    if (wallet) {
+      setSelectedWallet(wallet);
+      if (typeof window !== "undefined") localStorage.setItem(storageKey, wallet.id);
+    }
+  };
+  const refreshWallets = async () => {
+    await loadWallets();
+  };
+  const value = {
+    selectedWallet,
+    wallets,
+    selectWallet,
+    refreshWallets,
+    isLoading
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WalletContext.Provider, { value, children });
+}
+function useWallets() {
+  const context = (0, import_react2.useContext)(WalletContext);
+  if (context === void 0) {
+    throw new Error("useWallets must be used within a WalletProvider");
+  }
+  return context;
+}
+
+// src/core/storage-adapter.ts
+var import_helpers = require("cilantro-sdk/helpers");
+var storageAdapterInstance = null;
+var initializationPromise = null;
+async function initializeStorageAdapter() {
+  if (storageAdapterInstance) return storageAdapterInstance;
+  if (initializationPromise) return initializationPromise;
+  if (typeof window === "undefined") {
+    throw new Error("Storage adapter can only be initialized in browser environment.");
+  }
+  initializationPromise = (async () => {
+    try {
+      storageAdapterInstance = (0, import_helpers.createIndexedDBAdapter)();
+      return storageAdapterInstance;
+    } catch (error) {
+      initializationPromise = null;
+      throw error;
+    }
+  })();
+  return initializationPromise;
+}
+function getStorageAdapter() {
+  if (storageAdapterInstance) return storageAdapterInstance;
+  if (typeof window === "undefined") {
+    throw new Error("Storage adapter can only be initialized in browser environment.");
+  }
+  storageAdapterInstance = (0, import_helpers.createIndexedDBAdapter)();
+  return storageAdapterInstance;
+}
+
+// src/providers/CilantroProvider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function CilantroProvider({
+  children,
+  platformApiKey: platformApiKey2,
+  apiUrl: apiUrl2,
+  jwtStorageKey,
+  walletStorageKey,
+  onLoginSuccess,
+  onLogout,
+  onRegisterSuccess
+}) {
+  (0, import_react3.useEffect)(() => {
+    initializeStorageAdapter().catch((err) => {
+      console.error("[CilantroProvider] Failed to initialize storage adapter:", err);
+    });
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    CilantroAuthProvider,
+    {
+      platformApiKey: platformApiKey2,
+      apiUrl: apiUrl2,
+      jwtStorageKey,
+      onLoginSuccess,
+      onLogout,
+      onRegisterSuccess,
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(WalletProvider, { storageKey: walletStorageKey, children })
+    }
+  );
+}
+
+// src/hooks/useSigners.ts
+var import_react4 = require("react");
+
+// src/core/signer-helpers.ts
+var import_helpers2 = require("cilantro-sdk/helpers");
+var import_wallet2 = require("cilantro-sdk/wallet");
+async function loadSigners(walletId) {
+  if (!walletId) return [];
+  try {
+    let signersResult = await (0, import_helpers2.getSigners)(walletId);
+    let onChainSigners = extractOnChainSigners(signersResult);
+    let authSigners = extractAuthenticationSigners(signersResult);
+    if ((!onChainSigners || !Array.isArray(onChainSigners) || onChainSigners.length === 0) && (!authSigners || !Array.isArray(authSigners) || authSigners.length === 0)) {
+      const response = await (0, import_wallet2.listSigners)(walletId);
+      onChainSigners = extractOnChainSigners(response);
+      authSigners = extractAuthenticationSigners(response);
+    }
+    const processedOnChain = onChainSigners.filter((s) => s && typeof s === "object").map((signer) => processSigner(signer, "onchain"));
+    const processedAuth = authSigners.filter((s) => s && typeof s === "object").map((signer) => processSigner(signer, "authenticationsigner"));
+    return [...processedOnChain, ...processedAuth].filter((s) => s.id && (s.type || s.signerType));
+  } catch (error) {
+    console.error("Failed to load signers:", error);
+    return [];
+  }
+}
+function processSigner(signer, category) {
+  const parsed = (0, import_helpers2.parseSignerResponse)(signer);
+  const signerId = signer.id ?? signer.signerId ?? parsed.signerId;
+  const signerType = signer.signerType ?? signer.type ?? parsed.type;
+  const signerPubkey = signer.signerPubkey ?? signer.publicKey ?? parsed.publicKey ?? "";
+  const authId = signer.authId ?? parsed.email ?? parsed.phone;
+  const walletId = signer.walletId ?? parsed.walletId;
+  let email = signer.email ?? parsed.email;
+  let phone = signer.phone ?? parsed.phone;
+  if (!email && !phone && authId) {
+    if (signerType === "email") email = authId;
+    else if (signerType === "phone") phone = authId;
+  }
+  const signerConfig = signer.signerConfig;
+  if (signerConfig) {
+    if (!email && signerConfig.email) email = signerConfig.email;
+    if (!phone && signerConfig.phone) phone = signerConfig.phone;
+  }
+  const isActive = signer.isActive !== void 0 ? signer.isActive : parsed.isActive !== void 0 ? parsed.isActive : true;
+  return {
+    ...signer,
+    id: signerId,
+    signerId,
+    walletId: walletId ?? "",
+    type: signerType,
+    signerType,
+    publicKey: signerPubkey,
+    signerPubkey,
+    email,
+    phone,
+    isActive,
+    credentialId: signer.credentialId ?? (signerType === "passkey" ? authId : void 0),
+    authId,
+    deviceIdentities: signer.deviceIdentities,
+    signerConfig: signer.signerConfig,
+    permissions: signer.permissions,
+    signerCategory: category
+  };
+}
+function getSignerType(signer) {
+  return signer.type || signer.signerType || "";
+}
+function getSignerTypeLabel(type) {
+  if (!type) return "Unknown";
+  const t = type.toLowerCase();
+  if (t === "email") return "Email";
+  if (t === "phone") return "Phone";
+  if (t === "external" || t === "external-wallet") return "External Wallet";
+  if (t === "passkey") return "Passkey";
+  if (t === "api-key" || t === "apikey") return "API Key";
+  return type;
+}
+function getSignerDisplayName(signer) {
+  const signerType = getSignerType(signer);
+  const typeLabel = getSignerTypeLabel(signerType);
+  const shortId = signer.id.length > 8 ? `${signer.id.slice(0, 4)}...${signer.id.slice(-4)}` : signer.id;
+  if (signer.email) return `${typeLabel}: ${signer.email}`;
+  if (signer.phone) return `${typeLabel}: ${signer.phone}`;
+  if (signerType === "passkey") {
+    const credId = signer.credentialId ?? signer.authId ?? signer.signerConfig?.credentialId;
+    if (credId) {
+      const shortCredId = credId.length > 12 ? `${credId.slice(0, 6)}...${credId.slice(-6)}` : credId;
+      return `${typeLabel} (${shortCredId})`;
+    }
+    return `${typeLabel} (${shortId})`;
+  }
+  return `${typeLabel} (${shortId})`;
+}
+function getSignerUniqueId(signer) {
+  if (signer.id) return signer.id.length > 12 ? `${signer.id.slice(0, 6)}...${signer.id.slice(-6)}` : signer.id;
+  if (signer.publicKey) return `${signer.publicKey.slice(0, 6)}...${signer.publicKey.slice(-6)}`;
+  return "Unknown";
+}
+function extractSignerInfo(signer) {
+  const signerType = signer.type || signer.signerType;
+  const signerId = signer.id || signer.signerId;
+  if (!signerType) throw new Error(`Signer type is missing. Signer data: ${JSON.stringify(signer)}`);
+  if (!signerId) throw new Error(`Signer ID is missing. Signer data: ${JSON.stringify(signer)}`);
+  return { signerId, signerType };
+}
+
+// src/hooks/useSigners.ts
+function useSigners(options = {}) {
+  const { walletId: walletIdOption } = options;
+  const { token } = useCilantroAuth();
+  const [signers, setSigners] = (0, import_react4.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const load = (0, import_react4.useCallback)(async (walletId) => {
+    if (!walletId) {
+      setSigners([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (token) setSdkAuth(token);
+      const list = await loadSigners(walletId);
+      setSigners(list);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      setSigners([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [token]);
+  (0, import_react4.useEffect)(() => {
+    const id = walletIdOption ?? void 0;
+    if (id) load(id);
+    else {
+      setSigners([]);
+      setError(null);
+    }
+  }, [walletIdOption, load]);
+  const refresh = (0, import_react4.useCallback)(async () => {
+    const id = walletIdOption ?? void 0;
+    if (id) await load(id);
+  }, [walletIdOption, load]);
+  return { signers, isLoading, error, refresh };
+}
+
+// src/hooks/useSignerSelection.ts
+var import_react5 = require("react");
+function useSignerSelection(options = {}) {
+  const { walletId: walletIdOverride, signingMethod = "sdk-signer" } = options;
+  const { selectedWallet } = useWallets();
+  const effectiveWalletId = walletIdOverride ?? selectedWallet?.id ?? selectedWallet?.walletId ?? "";
+  const { signers: availableSigners, isLoading: isLoadingSigners } = useSigners({
+    walletId: effectiveWalletId || null
+  });
+  const [selectedWalletId, setSelectedWalletId] = (0, import_react5.useState)(effectiveWalletId);
+  const [selectedSigner, setSelectedSigner] = (0, import_react5.useState)(null);
+  (0, import_react5.useEffect)(() => {
+    setSelectedWalletId(effectiveWalletId);
+  }, [effectiveWalletId]);
+  (0, import_react5.useEffect)(() => {
+    if (signingMethod !== "sdk-signer") {
+      setSelectedSigner(null);
+    }
+  }, [signingMethod]);
+  const reset = (0, import_react5.useCallback)(() => {
+    setSelectedWalletId("");
+    setSelectedSigner(null);
+  }, []);
+  return {
+    selectedWalletId: selectedWalletId || effectiveWalletId,
+    setSelectedWalletId,
+    availableSigners,
+    selectedSigner,
+    setSelectedSigner,
+    isLoadingSigners,
+    reset
+  };
+}
+
+// src/hooks/useMessageSigning.ts
+var import_react6 = require("react");
+
+// src/core/signer-signing/core.ts
+var import_web3 = require("@solana/web3.js");
+var import_helpers3 = require("cilantro-sdk/helpers");
+
+// src/core/signer-signing/constants.ts
+var CACHE_CONFIG = { enabled: true, ttl: 3e5 };
+var SIGNER_TYPES = {
+  EMAIL: "email",
+  PHONE: "phone",
+  PASSKEY: "passkey",
+  EXTERNAL: "external",
+  API_KEY: "apiKey"
+};
+function isValidSignerType(type) {
+  return Object.values(SIGNER_TYPES).includes(type);
+}
+
+// src/core/signer-signing/storage.ts
+function getSignerStorage() {
+  return getStorageAdapter();
+}
+function getStorageOptions() {
+  return {
+    deviceKeyManager: getSignerStorage(),
+    cache: CACHE_CONFIG
+  };
+}
+
+// src/core/signer-signing/core.ts
+async function getSignerPublicKey(walletId, signer, signerType, signerId) {
+  const existingPubkey = signer.signerPubkey || signer.publicKey;
+  if (existingPubkey && typeof existingPubkey === "string" && existingPubkey.trim()) {
+    return new import_web3.PublicKey(existingPubkey.trim());
+  }
+  const storageOptions = getStorageOptions();
+  if (signerType === SIGNER_TYPES.EMAIL) {
+    const keypair = await (0, import_helpers3.getEmailSignerKeypair)(walletId, signerId, storageOptions);
+    return new import_web3.PublicKey(keypair.publicKey);
+  }
+  if (signerType === SIGNER_TYPES.PHONE) {
+    const keypair = await (0, import_helpers3.getPhoneSignerKeypair)(walletId, signerId, storageOptions);
+    return new import_web3.PublicKey(keypair.publicKey);
+  }
+  if (signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY) {
+    const keypair = await (0, import_helpers3.deriveSignerKeypair)(walletId, signerId, signerType, storageOptions);
+    return new import_web3.PublicKey(keypair.publicKey);
+  }
+  throw new Error(`Unsupported signer type: ${signerType}`);
+}
+
+// src/core/signer-signing/message-signing.ts
+var import_helpers6 = require("cilantro-sdk/helpers");
+
+// src/core/signer-creation.ts
+var import_web32 = require("@solana/web3.js");
+var import_helpers4 = require("cilantro-sdk/helpers");
+var import_transactions = require("cilantro-sdk/transactions");
+var import_wallet3 = require("cilantro-sdk/wallet");
+async function createEmailSignerHelper(walletId, email) {
+  const trimmedEmail = email.trim();
+  if (!trimmedEmail) throw new Error("Email address is required");
+  if (!(0, import_helpers4.isValidEmail)(trimmedEmail)) throw new Error("Invalid email address format");
+  const deviceKeyManager = getStorageAdapter();
+  return await (0, import_helpers4.createEmailSignerHelper)(walletId, { email: trimmedEmail, deviceKeyManager });
+}
+async function createPhoneSignerHelper(walletId, phone) {
+  const trimmedPhone = phone.trim();
+  if (!trimmedPhone) throw new Error("Phone number is required");
+  if (!(0, import_helpers4.isValidPhone)(trimmedPhone)) throw new Error("Invalid phone number format");
+  const deviceKeyManager = getStorageAdapter();
+  return await (0, import_helpers4.createPhoneSignerHelper)(walletId, { phone: trimmedPhone, deviceKeyManager });
+}
+async function createExternalSignerHelper(walletId, address) {
+  if (!address.trim()) throw new Error("Wallet address is required");
+  return await (0, import_wallet3.createExternalWalletSigner)(walletId, { address: address.trim(), chain: "solana" });
+}
+async function registerPasskeySigner(walletId) {
+  if (!(0, import_helpers4.isWebAuthnSupported)()) throw new Error("WebAuthn is not supported in this browser");
+  return await (0, import_helpers4.registerPasskeyComplete)(walletId);
+}
+async function signWithPasskey(walletId, signerId, message, options) {
+  if (!(0, import_helpers4.isWebAuthnSupported)()) throw new Error("WebAuthn is not supported in this browser");
+  const messageBytes = new TextEncoder().encode(message);
+  const signature = await (0, import_helpers4.signWithPasskeySigner)(walletId, signerId, messageBytes, options);
+  return {
+    signature: Buffer.from(signature).toString("hex"),
+    signer: signerId
+  };
+}
+async function signAndSendPasskeyTransaction(walletId, signerId, transaction, options) {
+  if (!(0, import_helpers4.isWebAuthnSupported)()) throw new Error("WebAuthn is not supported in this browser");
+  let credentialId = options?.credentialId;
+  if (!credentialId) {
+    const signers = await loadSigners(walletId);
+    const passkeySigner = signers.find((s) => s.id === signerId || s.signerId === signerId);
+    if (!passkeySigner) {
+      throw new Error(
+        `Passkey signer ${signerId} not found in wallet. Available signers: ${signers.map((s) => `${s.id} (${s.type})`).join(", ")}`
+      );
+    }
+    credentialId = passkeySigner.credentialId ?? passkeySigner.signerConfig?.credentialId ?? passkeySigner.authId;
+    if (!credentialId) {
+      throw new Error(`Credential ID not found for passkey signer ${signerId}.`);
+    }
+  }
+  let mintAddress = options?.mintAddress;
+  if (!mintAddress && transaction.instructions.length > 0) {
+    const systemProgramId = new import_web32.PublicKey("11111111111111111111111111111111");
+    const feePayer = transaction.feePayer || systemProgramId;
+    transaction.instructions.forEach((ix) => {
+      ix.keys.forEach((key) => {
+        if (key.isWritable && key.isSigner && !key.pubkey.equals(feePayer) && !mintAddress) {
+          mintAddress = key.pubkey.toString();
+        }
+      });
+    });
+  }
+  const unsignedTransaction = transaction.serialize({ verifySignatures: false }).toString("base64");
+  const authOptions = await (0, import_wallet3.startPasskeyAuthentication)(walletId, {
+    credentialId: options?.credentialId
+  });
+  const authData = extractResponseData(authOptions);
+  if (!authData) throw new Error("Failed to get authentication options");
+  const authDataValue = authData && typeof authData === "object" && "data" in authData ? authData.data : authData;
+  const credential = await (0, import_helpers4.authenticateWithPasskey)(
+    authDataValue,
+    { useBrowserAutofill: options?.useBrowserAutofill ?? false }
+  );
+  const formattedCredential = (0, import_helpers4.formatAuthenticationResponse)(credential);
+  const dto = {
+    walletId,
+    credentialId,
+    unsignedTransaction,
+    signature: formattedCredential.response.signature,
+    authenticatorData: formattedCredential.response.authenticatorData,
+    clientDataJSON: formattedCredential.response.clientDataJSON
+  };
+  const result = await (0, import_transactions.sendRawPasskeyTransaction)(dto);
+  const resultData = extractResponseData(result);
+  return { signature: resultData?.signature ?? "", status: resultData?.status };
+}
+
+// src/core/signer-signing/errors.ts
+var import_helpers5 = require("cilantro-sdk/helpers");
+function handleDeviceKeyError(error, signerType) {
+  if (error instanceof import_helpers5.DeviceKeyNotFoundError) {
+    throw new Error(
+      `Device key not found. Please create the ${signerType} signer first using the Signers page. The device key is generated when you create the signer.`
+    );
+  }
+  if (error instanceof import_helpers5.DeviceKeyMismatchError) {
+    throw new Error(
+      "Device key mismatch. The stored device key doesn't match the server. You may need to create a new signer or update the device identity."
+    );
+  }
+  if (error instanceof import_helpers5.SignerNotFoundError) {
+    throw new Error(`Signer not found. Please ensure the ${signerType} signer exists.`);
+  }
+  if (error instanceof import_helpers5.SignerInactiveError) {
+    throw new Error(`${signerType} signer is not active. Please activate the signer first.`);
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("Device key not found") || error.name === "DeviceKeyNotFoundError") {
+      throw new Error(
+        `Device key not found. Please create the ${signerType} signer first using the Signers page. The device key is generated when you create the signer.`
+      );
+    }
+    if (error.message.includes("Device key mismatch") || error.name === "DeviceKeyMismatchError") {
+      throw new Error(
+        "Device key mismatch. The stored device key doesn't match the server. You may need to create a new signer or update the device identity."
+      );
+    }
+  }
+  throw error;
+}
+
+// src/core/signer-signing/signer-types.ts
+function extractSignerInfo2(signer) {
+  const signerType = signer.type || signer.signerType;
+  const signerId = signer.id || signer.signerId;
+  if (!signerType || !signerId) {
+    throw new Error(`Signer type or ID is missing. Signer data: ${JSON.stringify(signer)}`);
+  }
+  if (!isValidSignerType(signerType)) {
+    throw new Error(`Unsupported signer type: ${signerType}`);
+  }
+  return { signerType, signerId };
+}
+function requiresActiveStatus(signerType) {
+  return signerType === SIGNER_TYPES.EMAIL || signerType === SIGNER_TYPES.PHONE || signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY;
+}
+function validateSignerActive(signer, signerType) {
+  if (requiresActiveStatus(signerType) && !signer.isActive) {
+    throw new Error(`${signerType} signer is not active. Please activate the signer first.`);
+  }
+}
+
+// src/core/signer-signing/message-signing.ts
+async function signMessageWithSigner(walletId, signer, messageText) {
+  const { signerType, signerId } = extractSignerInfo2(signer);
+  const message = new TextEncoder().encode(messageText);
+  if (signerType === SIGNER_TYPES.EMAIL) {
+    validateSignerActive(signer, signerType);
+    const storageOptions = getStorageOptions();
+    try {
+      const signature = await (0, import_helpers6.signWithEmailSigner)(walletId, signerId, message, storageOptions);
+      const keypair = await (0, import_helpers6.getEmailSignerKeypair)(walletId, signerId, storageOptions);
+      return {
+        signature: Buffer.from(signature).toString("hex"),
+        publicKey: Buffer.from(keypair.publicKey).toString("hex"),
+        signerType: SIGNER_TYPES.EMAIL
+      };
+    } catch (error) {
+      throw handleDeviceKeyError(error, SIGNER_TYPES.EMAIL);
+    }
+  }
+  if (signerType === SIGNER_TYPES.PHONE) {
+    validateSignerActive(signer, signerType);
+    const storageOptions = getStorageOptions();
+    try {
+      const signature = await (0, import_helpers6.signWithPhoneSigner)(walletId, signerId, message, storageOptions);
+      const keypair = await (0, import_helpers6.getPhoneSignerKeypair)(walletId, signerId, storageOptions);
+      return {
+        signature: Buffer.from(signature).toString("hex"),
+        publicKey: Buffer.from(keypair.publicKey).toString("hex"),
+        signerType: SIGNER_TYPES.PHONE
+      };
+    } catch (error) {
+      throw handleDeviceKeyError(error, SIGNER_TYPES.PHONE);
+    }
+  }
+  if (signerType === SIGNER_TYPES.PASSKEY) {
+    const signResult = await signWithPasskey(walletId, signerId, messageText, { useBrowserAutofill: false });
+    return {
+      signature: signResult.signature,
+      signerType: SIGNER_TYPES.PASSKEY,
+      signer: signResult.signer
+    };
+  }
+  if (signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY) {
+    validateSignerActive(signer, signerType);
+    const storageOptions = getStorageOptions();
+    const signature = await (0, import_helpers6.signWithSigner)(walletId, signerId, signerType, message, storageOptions);
+    const keypair = await (0, import_helpers6.deriveSignerKeypair)(walletId, signerId, signerType, storageOptions);
+    return {
+      signature: Buffer.from(signature).toString("hex"),
+      publicKey: Buffer.from(keypair.publicKey).toString("base64"),
+      signerType
+    };
+  }
+  throw new Error(`Unsupported signer type: ${signerType}`);
+}
+
+// src/core/signer-signing/transaction-signing.ts
+var import_helpers7 = require("cilantro-sdk/helpers");
+var import_wallet4 = require("cilantro-sdk/wallet");
+
+// src/core/signer-signing/validation.ts
+var import_web33 = require("@solana/web3.js");
+async function validateSignerInTransaction(signedTransactionBase64, expectedSignerPublicKey) {
+  const errors = [];
+  const warnings = [];
+  try {
+    const transactionBuffer = Buffer.from(signedTransactionBase64, "base64");
+    const transaction = import_web33.Transaction.from(transactionBuffer);
+    let allSignaturesValid = true;
+    try {
+      transaction.verifySignatures();
+    } catch (error) {
+      allSignaturesValid = false;
+      errors.push(`Signature verification failed: ${extractErrorMessage(error)}`);
+    }
+    const signers = transaction.signatures.map((sig) => {
+      const publicKeyStr = sig.publicKey.toString();
+      const hasSignature = sig.signature !== null && sig.signature.length > 0;
+      const signatureLength = sig.signature !== null ? sig.signature.length : 0;
+      let matchesExpected = false;
+      if (expectedSignerPublicKey) {
+        const expectedPubkey = typeof expectedSignerPublicKey === "string" ? new import_web33.PublicKey(expectedSignerPublicKey) : expectedSignerPublicKey;
+        matchesExpected = sig.publicKey.equals(expectedPubkey);
+      }
+      if (!hasSignature) warnings.push(`Signer ${publicKeyStr} has no signature (unsigned)`);
+      return { publicKey: publicKeyStr, hasSignature, signatureLength, matchesExpected };
+    });
+    let expectedSignerFound = false;
+    if (expectedSignerPublicKey) {
+      const expectedPubkey = typeof expectedSignerPublicKey === "string" ? new import_web33.PublicKey(expectedSignerPublicKey) : expectedSignerPublicKey;
+      expectedSignerFound = signers.some((s) => s.matchesExpected);
+      if (!expectedSignerFound) {
+        errors.push(`Expected signer ${expectedPubkey.toString()} not found in transaction signers`);
+      }
+    }
+    if (expectedSignerFound && expectedSignerPublicKey) {
+      const expectedSigner = signers.find((s) => s.matchesExpected);
+      if (expectedSigner && !expectedSigner.hasSignature) {
+        errors.push(
+          `Expected signer ${typeof expectedSignerPublicKey === "string" ? expectedSignerPublicKey : expectedSignerPublicKey.toString()} is present but has no signature`
+        );
+      }
+    }
+    const isValid = allSignaturesValid && (expectedSignerPublicKey ? expectedSignerFound : true) && errors.length === 0;
+    return {
+      isValid,
+      transaction,
+      signers,
+      expectedSignerFound,
+      allSignaturesValid,
+      feePayer: transaction.feePayer?.toString(),
+      recentBlockhash: transaction.recentBlockhash ?? void 0,
+      errors,
+      warnings
+    };
+  } catch (error) {
+    errors.push(`Failed to deserialize transaction: ${extractErrorMessage(error)}`);
+    throw new Error(
+      `Transaction validation failed: ${errors.join("; ")}
+Original error: ${extractErrorMessage(error)}`
+    );
+  }
+}
+
+// src/core/signer-signing/transaction-signing.ts
+function prepareTransactionForSigning(transaction, signerPublicKey) {
+  const signerPubkeyStr = signerPublicKey.toString();
+  const hasSignerInSignatures = transaction.signatures.some(
+    (sig) => sig.publicKey.toString() === signerPubkeyStr
+  );
+  if (!hasSignerInSignatures) {
+    transaction.signatures.push({
+      publicKey: signerPublicKey,
+      signature: null
+    });
+  }
+  if (transaction.feePayer) {
+    const feePayerStr = transaction.feePayer.toString();
+    const hasFeePayerInSignatures = transaction.signatures.some(
+      (sig) => sig.publicKey.toString() === feePayerStr
+    );
+    if (!hasFeePayerInSignatures) {
+      transaction.signatures.push({ publicKey: transaction.feePayer, signature: null });
+    }
+  }
+}
+async function signTransactionWithEmailOrPhone(walletId, signerId, signerType, unsignedTransactionBase64) {
+  const storageOptions = getStorageOptions();
+  if (signerType === SIGNER_TYPES.EMAIL) {
+    return await (0, import_helpers7.signTransactionWithEmailSigner)(
+      walletId,
+      signerId,
+      unsignedTransactionBase64,
+      storageOptions
+    );
+  }
+  return await (0, import_helpers7.signTransactionWithPhoneSigner)(
+    walletId,
+    signerId,
+    unsignedTransactionBase64,
+    storageOptions
+  );
+}
+async function submitSignedTransaction(walletId, signedTransactionBase64) {
+  const submitResult = await (0, import_wallet4.submitTransaction)(walletId, {
+    signedTransaction: signedTransactionBase64
+  });
+  const resultData = extractResponseData(submitResult);
+  if (!resultData?.signature) throw new Error("Server did not return a transaction signature");
+  return {
+    signature: resultData.signature,
+    confirmationStatus: resultData.status === "confirmed" ? "confirmed" : "pending"
+  };
+}
+async function handlePasskeyTransaction(walletId, signerId, transaction, connection) {
+  if (!connection) {
+    throw new Error(
+      "Connection is required for passkey sign-and-send. Pass the connection from your Solana config to useTransactionSigning / TransactionSigningForm."
+    );
+  }
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+  const result = await signAndSendPasskeyTransaction(walletId, signerId, transaction, {
+    useBrowserAutofill: false
+  });
+  let confirmationStatus = "confirmed";
+  try {
+    await connection.confirmTransaction({
+      signature: result.signature,
+      blockhash,
+      lastValidBlockHeight
+    });
+  } catch (error) {
+    const errorMsg = extractErrorMessage(error);
+    if (errorMsg.includes("block height exceeded") || errorMsg.includes("expired") || errorMsg.includes("timeout")) {
+      confirmationStatus = "pending";
+    } else {
+      throw new Error(`Transaction confirmation failed: ${errorMsg}. Signature: ${result.signature}`);
+    }
+  }
+  return { signature: result.signature, confirmationStatus };
+}
+async function handleEmailOrPhoneTransaction(walletId, signer, signerType, signerId, transaction) {
+  validateSignerActive(signer, signerType);
+  const signerPublicKey = await getSignerPublicKey(walletId, signer, signerType, signerId);
+  prepareTransactionForSigning(transaction, signerPublicKey);
+  const unsignedTransactionBase64 = Buffer.from(
+    transaction.serialize({ verifySignatures: false })
+  ).toString("base64");
+  let signedTransactionBase64;
+  try {
+    signedTransactionBase64 = await signTransactionWithEmailOrPhone(
+      walletId,
+      signerId,
+      signerType,
+      unsignedTransactionBase64
+    );
+  } catch (error) {
+    handleDeviceKeyError(error, signerType);
+    throw error;
+  }
+  try {
+    const validationResult = await validateSignerInTransaction(
+      signedTransactionBase64,
+      signerPublicKey
+    );
+    if (!validationResult.isValid) {
+      console.error("Transaction validation failed:", {
+        errors: validationResult.errors,
+        warnings: validationResult.warnings
+      });
+    }
+  } catch (validationError) {
+    console.error("Validation error (non-fatal):", extractErrorMessage(validationError));
+  }
+  return await submitSignedTransaction(walletId, signedTransactionBase64);
+}
+async function handleExternalOrApiKeyTransaction(walletId, signer, signerType, signerId, transaction) {
+  validateSignerActive(signer, signerType);
+  const messageBytes = transaction.serializeMessage();
+  const storageOptions = getStorageOptions();
+  const signatureBytes = await (0, import_helpers7.signWithSigner)(
+    walletId,
+    signerId,
+    signerType,
+    messageBytes,
+    storageOptions
+  );
+  const signerPublicKey = await getSignerPublicKey(walletId, signer, signerType, signerId);
+  const signatureBuffer = Buffer.from(signatureBytes);
+  transaction.addSignature(signerPublicKey, signatureBuffer);
+  const signedTransactionBytes = transaction.serialize();
+  const signedTransactionBase64 = Buffer.from(signedTransactionBytes).toString("base64");
+  return await submitSignedTransaction(walletId, signedTransactionBase64);
+}
+async function signTransactionWithSigner(walletId, signer, transactionBuffer) {
+  const { signerType, signerId } = extractSignerInfo2(signer);
+  const storageOptions = getStorageOptions();
+  if (signerType === SIGNER_TYPES.EMAIL) {
+    validateSignerActive(signer, signerType);
+    try {
+      const signature = await (0, import_helpers7.signWithEmailSigner)(walletId, signerId, transactionBuffer, storageOptions);
+      return { signature: Buffer.from(signature).toString("hex"), signerType: SIGNER_TYPES.EMAIL };
+    } catch (error) {
+      throw handleDeviceKeyError(error, SIGNER_TYPES.EMAIL);
+    }
+  }
+  if (signerType === SIGNER_TYPES.PHONE) {
+    validateSignerActive(signer, signerType);
+    try {
+      const signature = await (0, import_helpers7.signWithPhoneSigner)(walletId, signerId, transactionBuffer, storageOptions);
+      return { signature: Buffer.from(signature).toString("hex"), signerType: SIGNER_TYPES.PHONE };
+    } catch (error) {
+      throw handleDeviceKeyError(error, SIGNER_TYPES.PHONE);
+    }
+  }
+  if (signerType === SIGNER_TYPES.PASSKEY) {
+    const { signWithPasskeySigner: signWithPasskeySigner2 } = await import("cilantro-sdk/helpers");
+    const signature = await signWithPasskeySigner2(walletId, signerId, transactionBuffer, {
+      useBrowserAutofill: false
+    });
+    return { signature: Buffer.from(signature).toString("hex"), signerType: SIGNER_TYPES.PASSKEY };
+  }
+  if (signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY) {
+    validateSignerActive(signer, signerType);
+    const signature = await (0, import_helpers7.signWithSigner)(
+      walletId,
+      signerId,
+      signerType,
+      transactionBuffer,
+      storageOptions
+    );
+    return { signature: Buffer.from(signature).toString("hex"), signerType };
+  }
+  throw new Error(`Unsupported signer type: ${signerType}`);
+}
+async function signAndSendTransactionWithSigner(walletId, signer, transaction, connection) {
+  const { signerType, signerId } = extractSignerInfo2(signer);
+  if (signerType === SIGNER_TYPES.PASSKEY) {
+    return await handlePasskeyTransaction(walletId, signerId, transaction, connection);
+  }
+  if (signerType === SIGNER_TYPES.EMAIL || signerType === SIGNER_TYPES.PHONE) {
+    return await handleEmailOrPhoneTransaction(walletId, signer, signerType, signerId, transaction);
+  }
+  if (signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY) {
+    return await handleExternalOrApiKeyTransaction(walletId, signer, signerType, signerId, transaction);
+  }
+  throw new Error(`Unsupported signer type: ${signerType}`);
+}
+
+// src/core/signer-signing/wallet-data.ts
+var import_web34 = require("@solana/web3.js");
+var import_wallet5 = require("cilantro-sdk/wallet");
+async function getWalletData(walletId) {
+  const walletDataResponse = await (0, import_wallet5.findOne)(walletId);
+  const walletData = extractResponseData(walletDataResponse);
+  if (!walletData) throw new Error("Wallet data is empty");
+  const address = String(
+    walletData.address ?? walletData.walletAddress ?? walletData.solanaAddress ?? walletData.publicKey ?? walletData.pubkey ?? ""
+  ).trim();
+  if (!address) throw new Error(`No wallet address found. Available fields: ${Object.keys(walletData).join(", ")}`);
+  const walletPublicKey = new import_web34.PublicKey(address);
+  const adminData = walletData.admin;
+  const adminPubkey = String(
+    walletData.adminSignerPubkey ?? walletData.adminSigner ?? adminData?.publicKey ?? ""
+  ).trim();
+  if (!adminPubkey) {
+    throw new Error(
+      `adminSignerPubkey not found in wallet data. Available fields: ${Object.keys(walletData).join(", ")}`
+    );
+  }
+  const adminSignerPubkey = new import_web34.PublicKey(adminPubkey);
+  return { walletPublicKey, adminSignerPubkey };
+}
+
+// src/hooks/useMessageSigning.ts
+function useMessageSigning(options) {
+  const {
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignMessage,
+    walletAdapterPublicKey
+  } = options;
+  const [messageText, setMessageText] = (0, import_react6.useState)("Hello, Solana!");
+  const [signResultState, setSignResultState] = (0, import_react6.useState)({ status: "idle" });
+  const [isSigning, setIsSigning] = (0, import_react6.useState)(false);
+  const handleSign = async () => {
+    setIsSigning(true);
+    setSignResultState({ status: "loading" });
+    try {
+      if (token) setSdkAuth(token);
+      if (!messageText.trim()) throw new Error("Please enter a message to sign.");
+      if (signingMethod === "wallet-adapter") {
+        if (!walletAdapterSignMessage) {
+          throw new Error("Wallet adapter signMessage not provided.");
+        }
+        const message = new TextEncoder().encode(messageText);
+        const signature = await walletAdapterSignMessage(message);
+        setSignResultState({
+          status: "success",
+          message: "Message signed successfully!",
+          detail: {
+            message: messageText,
+            signature: Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join(""),
+            publicKey: walletAdapterPublicKey ?? void 0
+          }
+        });
+        return;
+      }
+      if (!selectedSigner || !selectedWalletId) throw new Error("Please select a signer.");
+      const result = await signMessageWithSigner(selectedWalletId, selectedSigner, messageText);
+      const { signerType } = extractSignerInfo(selectedSigner);
+      setSignResultState({
+        status: "success",
+        message: `Message signed successfully with ${signerType} signer!`,
+        detail: { message: messageText, ...result }
+      });
+    } catch (error) {
+      const errorMsg = extractErrorMessage(error);
+      const isCancelled = errorMsg.toLowerCase().includes("cancel") || errorMsg.toLowerCase().includes("notallowederror");
+      setSignResultState({
+        status: "error",
+        message: isCancelled ? "User cancelled authentication" : errorMsg
+      });
+    } finally {
+      setIsSigning(false);
+    }
+  };
+  const reset = () => {
+    setMessageText("Hello, Solana!");
+    setSignResultState({ status: "idle" });
+  };
+  return {
+    messageText,
+    setMessageText,
+    signResultState,
+    isSigning,
+    handleSign,
+    reset
+  };
+}
+
+// src/hooks/useTransactionSigning.ts
+var import_react7 = require("react");
+function useTransactionSigning(options) {
+  const {
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignTransaction,
+    walletAdapterPublicKey,
+    connection
+  } = options;
+  const [transactionResultState, setTransactionResultState] = (0, import_react7.useState)({ status: "idle" });
+  const [isSigningTransaction, setIsSigningTransaction] = (0, import_react7.useState)(false);
+  const [isSendingTransaction, setIsSendingTransaction] = (0, import_react7.useState)(false);
+  const signTransaction = async (transaction) => {
+    setIsSigningTransaction(true);
+    setTransactionResultState({ status: "loading" });
+    try {
+      if (token) setSdkAuth(token);
+      if (signingMethod === "wallet-adapter") {
+        if (!walletAdapterSignTransaction || !walletAdapterPublicKey) {
+          throw new Error("Wallet adapter signTransaction or publicKey not provided.");
+        }
+        const signed = await walletAdapterSignTransaction(transaction);
+        setTransactionResultState({
+          status: "success",
+          message: "Transaction signed successfully!",
+          detail: { transaction: signed.serialize().toString("base64") }
+        });
+        return;
+      }
+      if (!selectedSigner || !selectedWalletId) throw new Error("Please select a signer.");
+      const { signerId, signerType } = extractSignerInfo(selectedSigner);
+      if (signerType === "passkey") {
+        throw new Error("Passkey signers cannot be used for sign-only. Use sign-and-send instead.");
+      }
+      const transactionBuffer = transaction.serializeMessage();
+      const result = await signTransactionWithSigner(
+        selectedWalletId,
+        selectedSigner,
+        transactionBuffer
+      );
+      setTransactionResultState({
+        status: "success",
+        message: `Transaction signed with ${signerType} signer!`,
+        detail: { ...result }
+      });
+    } catch (error) {
+      const errorMsg = extractErrorMessage(error);
+      const isCancelled = errorMsg.toLowerCase().includes("cancel") || errorMsg.toLowerCase().includes("notallowederror");
+      setTransactionResultState({
+        status: "error",
+        message: isCancelled ? "User cancelled authentication" : errorMsg
+      });
+    } finally {
+      setIsSigningTransaction(false);
+    }
+  };
+  const signAndSendTransaction = async (transaction) => {
+    setIsSendingTransaction(true);
+    setTransactionResultState({ status: "loading" });
+    try {
+      if (token) setSdkAuth(token);
+      if (signingMethod === "wallet-adapter") {
+        if (!walletAdapterSignTransaction || !walletAdapterPublicKey || !connection) {
+          throw new Error("Wallet adapter signTransaction, publicKey, or connection not provided.");
+        }
+        const signed = await walletAdapterSignTransaction(transaction);
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+        const signature = await connection.sendRawTransaction(Buffer.from(signed.serialize()));
+        await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight });
+        setTransactionResultState({
+          status: "success",
+          message: "Transaction sent successfully!",
+          detail: { signature, explorerUrl: `https://solscan.io/tx/${signature}?cluster=devnet` }
+        });
+        return;
+      }
+      if (!selectedSigner || !selectedWalletId) throw new Error("Please select a signer.");
+      const { signerType } = extractSignerInfo(selectedSigner);
+      const result = await signAndSendTransactionWithSigner(
+        selectedWalletId,
+        selectedSigner,
+        transaction,
+        connection ?? void 0
+      );
+      setTransactionResultState({
+        status: "success",
+        message: `Transaction sent with ${signerType} signer!`,
+        detail: {
+          signature: result.signature,
+          confirmationStatus: result.confirmationStatus,
+          explorerUrl: `https://solscan.io/tx/${result.signature}?cluster=devnet`
+        }
+      });
+    } catch (error) {
+      const errorMsg = extractErrorMessage(error);
+      const isCancelled = errorMsg.toLowerCase().includes("cancel") || errorMsg.toLowerCase().includes("notallowederror");
+      setTransactionResultState({
+        status: "error",
+        message: isCancelled ? "User cancelled transaction" : errorMsg,
+        detail: { error: errorMsg, walletId: selectedWalletId }
+      });
+    } finally {
+      setIsSendingTransaction(false);
+    }
+  };
+  const reset = () => {
+    setTransactionResultState({ status: "idle" });
+  };
+  return {
+    transactionResultState,
+    isSigningTransaction,
+    isSendingTransaction,
+    signTransaction,
+    signAndSendTransaction,
+    reset
+  };
+}
+
+// src/ui/select.tsx
+var React = __toESM(require("react"));
+var SelectPrimitive = __toESM(require("@radix-ui/react-select"));
+
+// src/ui/cn.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+
+// src/ui/select.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var Select = SelectPrimitive.Root;
+var SelectValue = SelectPrimitive.Value;
+var SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+  SelectPrimitive.Trigger,
+  {
+    ref,
+    className: cn(
+      "flex h-9 w-full items-center justify-between whitespace-nowrap rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SelectPrimitive.Icon, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "ml-2 h-4 w-4 shrink-0 opacity-50", children: "\u25BC" }) })
+    ]
+  }
+));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+var SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SelectPrimitive.Portal, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  SelectPrimitive.Content,
+  {
+    ref,
+    className: cn(
+      "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+      className
+    ),
+    position,
+    ...props,
+    children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      SelectPrimitive.Viewport,
+      {
+        className: cn(
+          "p-1",
+          position === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+        ),
+        children
+      }
+    )
+  }
+) }));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+var SelectItem = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+  SelectPrimitive.Item,
+  {
+    ref,
+    className: cn(
+      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "absolute right-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SelectPrimitive.ItemIndicator, { children: "\u2713" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SelectPrimitive.ItemText, { children })
+    ]
+  }
+));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+
+// src/components/WalletSelector.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function WalletSelector(props) {
+  const {
+    value,
+    onWalletChange,
+    className,
+    classNames,
+    placeholder = "Select a wallet",
+    renderTrigger,
+    renderList,
+    children
+  } = props;
+  const { wallets, selectedWallet, selectWallet, isLoading, refreshWallets } = useWallets();
+  const effectiveValue = value ?? selectedWallet?.id ?? selectedWallet?.walletId ?? "";
+  const selected = wallets.find((w) => w.id === effectiveValue || w.walletId === effectiveValue) ?? selectedWallet;
+  const handleSelect = (wallet) => {
+    selectWallet(wallet.id);
+    onWalletChange?.(wallet.id, wallet);
+  };
+  const handleValueChange = (id) => {
+    selectWallet(id);
+    onWalletChange?.(id, wallets.find((w) => w.id === id || w.walletId === id) ?? null);
+  };
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: children({
+      wallets,
+      selectedWallet: selected,
+      selectWallet: (id) => {
+        selectWallet(id);
+        onWalletChange?.(id, wallets.find((w) => w.id === id || w.walletId === id) ?? null);
+      },
+      isLoading,
+      refreshWallets
+    }) });
+  }
+  if (renderTrigger || renderList) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: cn(className, classNames?.root), "data-cilantro-wallet-selector": true, children: [
+      renderTrigger?.({ selectedWallet: selected, wallets, isLoading, open: false, setOpen: () => {
+      } }),
+      renderList?.({ wallets, selectedWallet: selected, onSelect: handleSelect, isLoading })
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-wallet-selector": true, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Select, { value: effectiveValue || void 0, onValueChange: handleValueChange, disabled: isLoading, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SelectTrigger, { className: classNames?.trigger, "aria-label": "Select wallet", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SelectValue, { placeholder: isLoading ? "Loading..." : placeholder }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SelectContent, { className: classNames?.content, children: wallets.map((w) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SelectItem, { value: w.id, className: classNames?.item, children: w.walletName || w.id }, w.id)) })
+  ] }) });
+}
+
+// src/ui/button.tsx
+var React2 = __toESM(require("react"));
+var import_react_slot = require("@radix-ui/react-slot");
+var import_class_variance_authority = require("class-variance-authority");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var buttonVariants = (0, import_class_variance_authority.cva)(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React2.forwardRef(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? import_react_slot.Slot : "button";
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Comp, { className: cn(buttonVariants({ variant, size, className })), ref, ...props });
+  }
+);
+Button.displayName = "Button";
+
+// src/components/SignerSelector.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function SignerSelector({
+  selectedWalletId,
+  availableSigners,
+  selectedSigner,
+  isLoadingSigners = false,
+  onSignerSelect,
+  className,
+  classNames,
+  renderList,
+  children
+}) {
+  if (!selectedWalletId) return null;
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_jsx_runtime7.Fragment, { children: children({ signers: availableSigners, selectedSigner, onSignerSelect, isLoading: isLoadingSigners }) });
+  }
+  if (renderList) {
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-signer-selector": true, children: renderList({
+      signers: availableSigners,
+      selectedSigner,
+      onSelect: onSignerSelect,
+      isLoading: isLoadingSigners,
+      getSignerDisplayName,
+      getSignerTypeLabel,
+      getSignerUniqueId
+    }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-signer-selector": true, role: "listbox", "aria-label": "Select signer", children: isLoadingSigners ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading signers..." }) : availableSigners.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No signers for this wallet." }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("ul", { className: cn("space-y-1", classNames?.list), children: availableSigners.map((signer) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("li", { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    Button,
+    {
+      type: "button",
+      variant: selectedSigner?.id === signer.id ? "secondary" : "ghost",
+      size: "sm",
+      className: cn("w-full justify-start", classNames?.item),
+      onClick: () => onSignerSelect(signer),
+      "aria-pressed": selectedSigner?.id === signer.id,
+      children: [
+        getSignerDisplayName(signer),
+        " (",
+        getSignerTypeLabel(signer.type || signer.signerType || ""),
+        ")"
+      ]
+    }
+  ) }, signer.id)) }) });
+}
+
+// src/components/DelegatedKeySelector.tsx
+var import_react8 = require("react");
+var import_delegated_keys = require("cilantro-sdk/delegated-keys");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function DelegatedKeySelector(props) {
+  const {
+    walletId,
+    value,
+    onChange,
+    filterActive = true,
+    className,
+    classNames,
+    placeholder = "Select a delegated key",
+    children
+  } = props;
+  const { token } = useCilantroAuth();
+  const [keys, setKeys] = (0, import_react8.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const loadKeys = (0, import_react8.useCallback)(async () => {
+    if (!walletId) {
+      setKeys([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (token) setSdkAuth(token);
+      const result = await (0, import_delegated_keys.findAll)(walletId);
+      const keysData = extractResponseData(result) ?? [];
+      const list = Array.isArray(keysData) ? keysData : [];
+      let loaded = list.filter((k) => k != null && typeof k === "object" && "id" in k).map((k) => ({
+        id: String(k.id ?? ""),
+        walletId: String(k.walletId ?? ""),
+        name: k.name,
+        publicKey: String(k.publicKey ?? ""),
+        permissions: k.permissions ?? {},
+        isActive: k.isActive !== false,
+        createdAt: k.createdAt,
+        expiresAt: k.expiresAt,
+        ...k
+      }));
+      if (filterActive) {
+        const now = Date.now();
+        loaded = loaded.filter((key) => {
+          if (!key.isActive) return false;
+          const exp = key.expiresAt ? new Date(key.expiresAt).getTime() : null;
+          return exp === null || exp > now;
+        });
+      }
+      setKeys(loaded);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setKeys([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [walletId, token, filterActive]);
+  (0, import_react8.useEffect)(() => {
+    loadKeys();
+  }, [loadKeys]);
+  const onSelect = (key) => {
+    onChange?.(key.id, key);
+  };
+  const handleValueChange = (id) => {
+    const key = keys.find((k) => k.id === id) ?? null;
+    onChange?.(id, key);
+  };
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_jsx_runtime8.Fragment, { children: children({ keys, selectedKeyId: value, onSelect, isLoading, error, refresh: loadKeys }) });
+  }
+  if (!walletId) {
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: cn(className, classNames?.root, "text-sm text-muted-foreground"), children: "Select a wallet first" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-delegated-key-selector": true, children: isLoading ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading delegated keys..." }) : error ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { className: cn("text-sm text-destructive", classNames?.message), role: "alert", children: error }) : keys.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No delegated keys found." }) : /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(Select, { value: (value ?? "") || void 0, onValueChange: handleValueChange, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectTrigger, { className: classNames?.trigger, "aria-label": "Select delegated key", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectValue, { placeholder }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectContent, { className: classNames?.content, children: keys.map((k) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SelectItem, { value: k.id, className: classNames?.item, children: k.name || k.publicKey.slice(0, 8) + "..." }, k.id)) })
+  ] }) });
+}
+
+// src/ui/textarea.tsx
+var React3 = __toESM(require("react"));
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var Textarea = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    "textarea",
+    {
+      className: cn(
+        "flex min-h-[80px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        className
+      ),
+      ref,
+      ...props
+    }
+  )
+);
+Textarea.displayName = "Textarea";
+
+// src/ui/label.tsx
+var React4 = __toESM(require("react"));
+var LabelPrimitive = __toESM(require("@radix-ui/react-label"));
+var import_class_variance_authority2 = require("class-variance-authority");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var labelVariants = (0, import_class_variance_authority2.cva)(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(LabelPrimitive.Root, { ref, className: cn(labelVariants(), className), ...props }));
+Label.displayName = LabelPrimitive.Root.displayName;
+
+// src/ui/card.tsx
+var React5 = __toESM(require("react"));
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var Card = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    "div",
+    {
+      ref,
+      className: cn("rounded-xl border bg-card text-card-foreground shadow", className),
+      ...props
+    }
+  )
+);
+Card.displayName = "Card";
+var CardHeader = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { ref, className: cn("flex flex-col space-y-1.5 p-6", className), ...props })
+);
+CardHeader.displayName = "CardHeader";
+var CardTitle = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    "h3",
+    {
+      ref,
+      className: cn("font-semibold leading-none tracking-tight", className),
+      ...props
+    }
+  )
+);
+CardTitle.displayName = "CardTitle";
+var CardDescription = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("p", { ref, className: cn("text-sm text-muted-foreground", className), ...props }));
+CardDescription.displayName = "CardDescription";
+var CardContent = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { ref, className: cn("p-6 pt-0", className), ...props })
+);
+CardContent.displayName = "CardContent";
+var CardFooter = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { ref, className: cn("flex items-center p-6 pt-0", className), ...props })
+);
+CardFooter.displayName = "CardFooter";
+
+// src/components/MessageSigningForm.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+function MessageSigningForm({
+  token: tokenOverride,
+  selectedWalletId: walletIdOverride,
+  selectedSigner: signerOverride,
+  signingMethod: methodOverride,
+  walletAdapterSignMessage,
+  walletAdapterPublicKey,
+  className,
+  classNames,
+  showContext = true,
+  showCharCount = false,
+  children
+}) {
+  const { token: contextToken } = useCilantroAuth();
+  const token = tokenOverride ?? contextToken;
+  const selection = useSignerSelection({
+    signingMethod: methodOverride ?? "sdk-signer",
+    walletId: walletIdOverride
+  });
+  const selectedWalletId = walletIdOverride ?? selection.selectedWalletId;
+  const selectedSigner = signerOverride ?? selection.selectedSigner;
+  const signingMethod = methodOverride ?? "sdk-signer";
+  const signing = useMessageSigning({
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignMessage,
+    walletAdapterPublicKey
+  });
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-message-signing-form": true, children: children({
+      messageText: signing.messageText,
+      setMessageText: signing.setMessageText,
+      signResultState: signing.signResultState,
+      isSigning: signing.isSigning,
+      handleSign: signing.handleSign,
+      reset: signing.reset
+    }) });
+  }
+  const resultStatus = signing.signResultState.status;
+  const isSuccess = resultStatus === "success";
+  const isError = resultStatus === "error";
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(Card, { className: cn(className, classNames?.root), "data-cilantro-message-signing-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CardTitle, { className: cn("text-lg", classNames?.title), children: "Sign message" }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CardDescription, { className: classNames?.description, children: "Sign a message with your selected wallet or signer. The signature proves you control the key." }),
+      showContext && (selectedWalletId || selectedSigner) && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("p", { className: cn("mt-1 text-xs text-muted-foreground", classNames?.context), children: [
+        selectedWalletId && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("span", { children: [
+          "Wallet: ",
+          selectedWalletId.slice(0, 8),
+          "\u2026"
+        ] }),
+        selectedSigner && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("span", { className: selectedWalletId ? " ml-2" : "", children: [
+          "Signer: ",
+          getSignerDisplayName(selectedSigner),
+          " (",
+          getSignerTypeLabel(selectedSigner.type || selectedSigner.signerType || ""),
+          ")"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Label, { htmlFor: "cilantro-message-text", className: classNames?.label, children: "Message" }),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+          Textarea,
+          {
+            id: "cilantro-message-text",
+            className: classNames?.textarea,
+            value: signing.messageText,
+            onChange: (e) => signing.setMessageText(e.target.value),
+            placeholder: "Enter the message you want to sign...",
+            rows: 4
+          }
+        ),
+        showCharCount && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("p", { className: cn("text-right text-xs text-muted-foreground", classNames?.charCount), children: [
+          signing.messageText.length,
+          " character",
+          signing.messageText.length !== 1 ? "s" : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { className: "flex flex-col gap-2 sm:flex-row sm:items-center", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+          Button,
+          {
+            type: "button",
+            className: cn("w-full sm:w-auto", classNames?.button),
+            onClick: signing.handleSign,
+            disabled: signing.isSigning || !signing.messageText.trim(),
+            children: signing.isSigning ? "Signing..." : "Sign message"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: cn("w-full sm:w-auto", classNames?.resetButton),
+            onClick: signing.reset,
+            disabled: signing.isSigning,
+            children: "Clear"
+          }
+        )
+      ] }),
+      resultStatus !== "idle" && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+        "div",
+        {
+          className: cn(
+            "rounded-lg border px-3 py-2 text-sm",
+            isSuccess && cn("border-green-500/50 bg-green-500/10 text-green-700 dark:text-green-400", classNames?.resultSuccess),
+            isError && cn("border-destructive/50 bg-destructive/10 text-destructive", classNames?.resultError),
+            resultStatus === "loading" && "border-muted bg-muted/50 text-muted-foreground",
+            classNames?.result
+          ),
+          "data-status": resultStatus,
+          children: [
+            signing.signResultState.message,
+            signing.signResultState.detail != null && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("pre", { className: cn("mt-2 overflow-auto rounded-md bg-muted/80 p-2 text-xs", classNames?.resultPre), children: JSON.stringify(signing.signResultState.detail, null, 2) })
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/TransactionSigningForm.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function TransactionSigningForm({
+  token: tokenOverride,
+  selectedWalletId: walletIdOverride,
+  selectedSigner: signerOverride,
+  signingMethod: methodOverride,
+  walletAdapterSignTransaction,
+  walletAdapterPublicKey,
+  connection,
+  className,
+  classNames,
+  showContext = true,
+  children
+}) {
+  const { token: contextToken } = useCilantroAuth();
+  const token = tokenOverride ?? contextToken;
+  const selection = useSignerSelection({
+    signingMethod: methodOverride ?? "sdk-signer",
+    walletId: walletIdOverride
+  });
+  const selectedWalletId = walletIdOverride ?? selection.selectedWalletId;
+  const selectedSigner = signerOverride ?? selection.selectedSigner;
+  const signingMethod = methodOverride ?? "sdk-signer";
+  const signing = useTransactionSigning({
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignTransaction,
+    walletAdapterPublicKey,
+    connection
+  });
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-transaction-signing-form": true, children: children({
+      transactionResultState: signing.transactionResultState,
+      isSigningTransaction: signing.isSigningTransaction,
+      isSendingTransaction: signing.isSendingTransaction,
+      signTransaction: signing.signTransaction,
+      signAndSendTransaction: signing.signAndSendTransaction,
+      reset: signing.reset
+    }) });
+  }
+  const resultStatus = signing.transactionResultState.status;
+  const isSuccess = resultStatus === "success";
+  const isError = resultStatus === "error";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(Card, { className: cn(className, classNames?.root), "data-cilantro-transaction-signing-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(CardTitle, { className: cn("text-lg", classNames?.title), children: "Sign transaction" }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(CardDescription, { className: classNames?.description, children: [
+        "Build a transaction in your app, then pass it to ",
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("code", { className: "text-xs", children: "signTransaction(tx)" }),
+        " to sign only, or ",
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("code", { className: "text-xs", children: "signAndSendTransaction(tx)" }),
+        " to sign and send. Use the render props (children) to wire your own UI."
+      ] }),
+      showContext && (selectedWalletId || selectedSigner) && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("p", { className: cn("mt-1 text-xs text-muted-foreground", classNames?.context), children: [
+        selectedWalletId && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { children: [
+          "Wallet: ",
+          selectedWalletId.slice(0, 8),
+          "\u2026"
+        ] }),
+        selectedSigner && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { className: selectedWalletId ? " ml-2" : "", children: [
+          "Signer: ",
+          getSignerDisplayName(selectedSigner),
+          " (",
+          getSignerTypeLabel(selectedSigner.type || selectedSigner.signerType || ""),
+          ")"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          className: classNames?.button,
+          onClick: signing.reset,
+          disabled: signing.isSigningTransaction || signing.isSendingTransaction,
+          children: "Reset status"
+        }
+      ),
+      resultStatus !== "idle" && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+        "div",
+        {
+          className: cn(
+            "rounded-lg border px-3 py-2 text-sm",
+            isSuccess && cn("border-green-500/50 bg-green-500/10 text-green-700 dark:text-green-400", classNames?.resultSuccess),
+            isError && cn("border-destructive/50 bg-destructive/10 text-destructive", classNames?.resultError),
+            resultStatus === "loading" && "border-muted bg-muted/50 text-muted-foreground",
+            classNames?.result
+          ),
+          "data-status": resultStatus,
+          children: [
+            signing.transactionResultState.message,
+            signing.transactionResultState.detail != null && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("pre", { className: cn("mt-2 overflow-auto rounded-md bg-muted/80 p-2 text-xs", classNames?.resultPre), children: JSON.stringify(signing.transactionResultState.detail, null, 2) })
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/LoginForm.tsx
+var import_react9 = require("react");
+
+// src/ui/input.tsx
+var React6 = __toESM(require("react"));
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var Input = React6.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+      "input",
+      {
+        type,
+        className: cn(
+          "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/components/LoginForm.tsx
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function LoginForm({
+  className,
+  classNames,
+  onSuccess,
+  onError,
+  submitLabel = "Sign in",
+  title = "Sign in",
+  description,
+  renderSwitchToRegister
+}) {
+  const { login, isLoading } = useCilantroAuth();
+  const [usernameOrEmail, setUsernameOrEmail] = (0, import_react9.useState)("");
+  const [password, setPassword] = (0, import_react9.useState)("");
+  const [error, setError] = (0, import_react9.useState)(null);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    setError(null);
+    try {
+      await login(usernameOrEmail.trim(), password);
+      onSuccess?.();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      onError?.(message);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(Card, { className: cn(className, classNames?.root), "data-cilantro-login-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(CardTitle, { className: classNames?.title, children: title }),
+      description != null && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(CardDescription, { className: classNames?.description, children: description })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(CardContent, { children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Label, { htmlFor: "cilantro-login-username", className: classNames?.label, children: "Username or email" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          Input,
+          {
+            id: "cilantro-login-username",
+            type: "text",
+            autoComplete: "username",
+            className: classNames?.input,
+            value: usernameOrEmail,
+            onChange: (e) => setUsernameOrEmail(e.target.value),
+            placeholder: "Username or email",
+            required: true,
+            disabled: isLoading
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Label, { htmlFor: "cilantro-login-password", className: classNames?.label, children: "Password" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          Input,
+          {
+            id: "cilantro-login-password",
+            type: "password",
+            autoComplete: "current-password",
+            className: classNames?.input,
+            value: password,
+            onChange: (e) => setPassword(e.target.value),
+            placeholder: "Password",
+            required: true,
+            disabled: isLoading
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        "div",
+        {
+          className: cn(
+            "rounded-md border border-destructive/50 bg-destructive/10 px-3 py-2 text-sm text-destructive",
+            classNames?.error
+          ),
+          role: "alert",
+          children: error
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !usernameOrEmail.trim() || !password,
+          children: isLoading ? "Signing in..." : submitLabel
+        }
+      ),
+      renderSwitchToRegister && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "text-center text-sm text-muted-foreground", children: renderSwitchToRegister() })
+    ] }) })
+  ] });
+}
+
+// src/components/RegisterForm.tsx
+var import_react10 = require("react");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+function RegisterForm({
+  className,
+  classNames,
+  onSuccess,
+  onError,
+  submitLabel = "Create account",
+  title = "Create an account",
+  description,
+  isActive = true,
+  renderSwitchToLogin
+}) {
+  const { register, isLoading } = useCilantroAuth();
+  const [username, setUsername] = (0, import_react10.useState)("");
+  const [email, setEmail] = (0, import_react10.useState)("");
+  const [password, setPassword] = (0, import_react10.useState)("");
+  const [error, setError] = (0, import_react10.useState)(null);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    setError(null);
+    try {
+      await register(username.trim(), email.trim(), password, isActive);
+      onSuccess?.();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      onError?.(message);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(Card, { className: cn(className, classNames?.root), "data-cilantro-register-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(CardTitle, { className: classNames?.title, children: title }),
+      description != null && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(CardDescription, { className: classNames?.description, children: description })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(CardContent, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Label, { htmlFor: "cilantro-register-username", className: classNames?.label, children: "Username" }),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+          Input,
+          {
+            id: "cilantro-register-username",
+            type: "text",
+            autoComplete: "username",
+            className: classNames?.input,
+            value: username,
+            onChange: (e) => setUsername(e.target.value),
+            placeholder: "Username",
+            required: true,
+            disabled: isLoading
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Label, { htmlFor: "cilantro-register-email", className: classNames?.label, children: "Email" }),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+          Input,
+          {
+            id: "cilantro-register-email",
+            type: "email",
+            autoComplete: "email",
+            className: classNames?.input,
+            value: email,
+            onChange: (e) => setEmail(e.target.value),
+            placeholder: "Email",
+            required: true,
+            disabled: isLoading
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Label, { htmlFor: "cilantro-register-password", className: classNames?.label, children: "Password" }),
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+          Input,
+          {
+            id: "cilantro-register-password",
+            type: "password",
+            autoComplete: "new-password",
+            className: classNames?.input,
+            value: password,
+            onChange: (e) => setPassword(e.target.value),
+            placeholder: "Password",
+            required: true,
+            disabled: isLoading
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        "div",
+        {
+          className: cn(
+            "rounded-md border border-destructive/50 bg-destructive/10 px-3 py-2 text-sm text-destructive",
+            classNames?.error
+          ),
+          role: "alert",
+          children: error
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !username.trim() || !email.trim() || !password,
+          children: isLoading ? "Creating account..." : submitLabel
+        }
+      ),
+      renderSwitchToLogin && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "text-center text-sm text-muted-foreground", children: renderSwitchToLogin() })
+    ] }) })
+  ] });
+}
+
+// src/components/AuthForm.tsx
+var import_react11 = require("react");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+function AuthForm({
+  defaultMode = "login",
+  className,
+  classNames,
+  onSuccess,
+  onError,
+  loginSubmitLabel = "Sign in",
+  registerSubmitLabel = "Create account",
+  loginTitle = "Welcome back",
+  registerTitle = "Create an account",
+  loginDescription = "Sign in with your username or email.",
+  registerDescription = "Enter your details to get started.",
+  switchToRegisterText = "Don't have an account? Create one",
+  switchToLoginText = "Already have an account? Sign in",
+  isActive = true
+}) {
+  const { login, register, isLoading } = useCilantroAuth();
+  const [mode, setMode] = (0, import_react11.useState)(defaultMode);
+  const [usernameOrEmail, setUsernameOrEmail] = (0, import_react11.useState)("");
+  const [username, setUsername] = (0, import_react11.useState)("");
+  const [email, setEmail] = (0, import_react11.useState)("");
+  const [password, setPassword] = (0, import_react11.useState)("");
+  const [error, setError] = (0, import_react11.useState)(null);
+  const isLogin = mode === "login";
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    setError(null);
+    try {
+      if (isLogin) {
+        await login(usernameOrEmail.trim(), password);
+      } else {
+        await register(username.trim(), email.trim(), password, isActive);
+      }
+      onSuccess?.();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      onError?.(message);
+    }
+  };
+  const switchMode = () => {
+    setMode(isLogin ? "register" : "login");
+    setError(null);
+  };
+  const canSubmit = isLogin ? usernameOrEmail.trim().length > 0 && password.length > 0 : username.trim().length > 0 && email.trim().length > 0 && password.length > 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(Card, { className: cn("w-full max-w-sm", className, classNames?.root), "data-cilantro-auth-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(CardHeader, { className: cn("space-y-1 text-center sm:text-left", classNames?.header), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CardTitle, { className: cn("text-xl", classNames?.title), children: isLogin ? loginTitle : registerTitle }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CardDescription, { className: classNames?.description, children: isLogin ? loginDescription : registerDescription })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CardContent, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      isLogin ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Label, { htmlFor: "cilantro-auth-username", className: classNames?.label, children: "Username or email" }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+            Input,
+            {
+              id: "cilantro-auth-username",
+              type: "text",
+              autoComplete: "username",
+              className: classNames?.input,
+              value: usernameOrEmail,
+              onChange: (e) => setUsernameOrEmail(e.target.value),
+              placeholder: "you@example.com",
+              required: true,
+              disabled: isLoading
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Label, { htmlFor: "cilantro-auth-password", className: classNames?.label, children: "Password" }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+            Input,
+            {
+              id: "cilantro-auth-password",
+              type: "password",
+              autoComplete: "current-password",
+              className: classNames?.input,
+              value: password,
+              onChange: (e) => setPassword(e.target.value),
+              placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022",
+              required: true,
+              disabled: isLoading
+            }
+          )
+        ] })
+      ] }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Label, { htmlFor: "cilantro-auth-reg-username", className: classNames?.label, children: "Username" }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+            Input,
+            {
+              id: "cilantro-auth-reg-username",
+              type: "text",
+              autoComplete: "username",
+              className: classNames?.input,
+              value: username,
+              onChange: (e) => setUsername(e.target.value),
+              placeholder: "johndoe",
+              required: true,
+              disabled: isLoading
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Label, { htmlFor: "cilantro-auth-reg-email", className: classNames?.label, children: "Email" }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+            Input,
+            {
+              id: "cilantro-auth-reg-email",
+              type: "email",
+              autoComplete: "email",
+              className: classNames?.input,
+              value: email,
+              onChange: (e) => setEmail(e.target.value),
+              placeholder: "you@example.com",
+              required: true,
+              disabled: isLoading
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Label, { htmlFor: "cilantro-auth-reg-password", className: classNames?.label, children: "Password" }),
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+            Input,
+            {
+              id: "cilantro-auth-reg-password",
+              type: "password",
+              autoComplete: "new-password",
+              className: classNames?.input,
+              value: password,
+              onChange: (e) => setPassword(e.target.value),
+              placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022",
+              required: true,
+              disabled: isLoading
+            }
+          )
+        ] })
+      ] }),
+      error && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "div",
+        {
+          className: cn(
+            "rounded-md border border-destructive/50 bg-destructive/10 px-3 py-2 text-sm text-destructive",
+            classNames?.error
+          ),
+          role: "alert",
+          children: error
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !canSubmit,
+          children: isLoading ? isLogin ? "Signing in..." : "Creating account..." : isLogin ? loginSubmitLabel : registerSubmitLabel
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("p", { className: cn("text-center text-sm text-muted-foreground", classNames?.toggle), children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "button",
+        {
+          type: "button",
+          className: cn("underline underline-offset-2 hover:text-foreground", classNames?.toggleLink),
+          onClick: switchMode,
+          disabled: isLoading,
+          children: isLogin ? switchToRegisterText : switchToLoginText
+        }
+      ) })
+    ] }) })
+  ] });
+}
+
+// src/components/AuthGuard.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+function AuthGuard({
+  children,
+  fallback,
+  className,
+  classNames,
+  showFallback = true
+}) {
+  const { isAuthenticated, isLoading } = useCilantroAuth();
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-auth-guard": true, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: cn("text-sm text-muted-foreground", classNames?.fallback), children: "Loading..." }) });
+  }
+  if (!isAuthenticated) {
+    if (!showFallback) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-auth-guard": true, children: fallback ?? /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(LoginForm, { className: classNames?.fallback }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_jsx_runtime18.Fragment, { children });
+}
+
+// src/components/AddSignerForm.tsx
+var import_react12 = require("react");
+
+// src/ui/dialog.tsx
+var React7 = __toESM(require("react"));
+var DialogPrimitive = __toESM(require("@radix-ui/react-dialog"));
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var Dialog = DialogPrimitive.Root;
+var DialogPortal = DialogPrimitive.Portal;
+var DialogOverlay = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  DialogPrimitive.Overlay,
+  {
+    ref,
+    className: cn(
+      "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props
+  }
+));
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
+var DialogContent = React7.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(DialogPortal, { children: [
+  /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(DialogOverlay, {}),
+  /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    DialogPrimitive.Content,
+    {
+      ref,
+      className: cn(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        className
+      ),
+      ...props,
+      children
+    }
+  )
+] }));
+DialogContent.displayName = DialogPrimitive.Content.displayName;
+var DialogHeader = ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: cn("flex flex-col space-y-1.5 text-center sm:text-left", className), ...props });
+DialogHeader.displayName = "DialogHeader";
+var DialogFooter = ({ className, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  "div",
+  {
+    className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className),
+    ...props
+  }
+);
+DialogFooter.displayName = "DialogFooter";
+var DialogTitle = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  DialogPrimitive.Title,
+  {
+    ref,
+    className: cn("text-lg font-semibold leading-none tracking-tight", className),
+    ...props
+  }
+));
+DialogTitle.displayName = DialogPrimitive.Title.displayName;
+var DialogDescription = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  DialogPrimitive.Description,
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+
+// src/components/AddSignerForm.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
+function AddSignerForm({
+  walletId,
+  open = true,
+  onOpenChange,
+  onSuccess,
+  onCancel,
+  onError,
+  className,
+  classNames,
+  asDialog = true
+}) {
+  const [signerType, setSignerType] = (0, import_react12.useState)(null);
+  const [email, setEmail] = (0, import_react12.useState)("");
+  const [phone, setPhone] = (0, import_react12.useState)("");
+  const [address, setAddress] = (0, import_react12.useState)("");
+  const [isSubmitting, setIsSubmitting] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const resetForm = () => {
+    setSignerType(null);
+    setEmail("");
+    setPhone("");
+    setAddress("");
+    setError(null);
+  };
+  const handleClose = (open2) => {
+    if (!open2) {
+      resetForm();
+      onCancel?.();
+    }
+    onOpenChange?.(open2);
+  };
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!signerType) return;
+    setError(null);
+    setIsSubmitting(true);
+    try {
+      if (signerType === "email") {
+        await createEmailSignerHelper(walletId, email);
+      } else if (signerType === "phone") {
+        await createPhoneSignerHelper(walletId, phone);
+      } else if (signerType === "passkey") {
+        await registerPasskeySigner(walletId);
+      } else if (signerType === "external") {
+        await createExternalSignerHelper(walletId, address);
+      }
+      resetForm();
+      onSuccess?.();
+      handleClose(false);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      onError?.(message);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const handlePasskeyClick = () => {
+    setSignerType("passkey");
+    setError(null);
+    setIsSubmitting(true);
+    registerPasskeySigner(walletId).then(() => {
+      resetForm();
+      onSuccess?.();
+      handleClose(false);
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      onError?.(message);
+    }).finally(() => setIsSubmitting(false));
+  };
+  const formContent = /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+    !signerType ? /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Label, { className: classNames?.label, children: "Signer type" }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "flex flex-wrap gap-2", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("email"),
+              disabled: isSubmitting,
+              children: "Email"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("phone"),
+              disabled: isSubmitting,
+              children: "Phone"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: handlePasskeyClick,
+              disabled: isSubmitting,
+              children: "Passkey"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("external"),
+              disabled: isSubmitting,
+              children: "External wallet"
+            }
+          )
+        ] })
+      ] }),
+      asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(DialogFooter, { className: "gap-2 sm:gap-0", children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          className: classNames?.cancelButton,
+          onClick: () => handleClose(false),
+          disabled: isSubmitting,
+          children: "Cancel"
+        }
+      ) })
+    ] }) : signerType === "email" ? /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Label, { htmlFor: "add-signer-email", className: classNames?.label, children: "Email" }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Input,
+          {
+            id: "add-signer-email",
+            type: "email",
+            autoComplete: "email",
+            className: classNames?.input,
+            value: email,
+            onChange: (e) => setEmail(e.target.value),
+            placeholder: "email@example.com",
+            required: true,
+            disabled: isSubmitting
+          }
+        )
+      ] }),
+      asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : signerType === "phone" ? /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Label, { htmlFor: "add-signer-phone", className: classNames?.label, children: "Phone number" }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Input,
+          {
+            id: "add-signer-phone",
+            type: "tel",
+            autoComplete: "tel",
+            className: classNames?.input,
+            value: phone,
+            onChange: (e) => setPhone(e.target.value),
+            placeholder: "+1234567890",
+            required: true,
+            disabled: isSubmitting
+          }
+        )
+      ] }),
+      asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : signerType === "external" ? /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Label, { htmlFor: "add-signer-address", className: classNames?.label, children: "Wallet address" }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Input,
+          {
+            id: "add-signer-address",
+            type: "text",
+            className: classNames?.input,
+            value: address,
+            onChange: (e) => setAddress(e.target.value),
+            placeholder: "Solana address",
+            required: true,
+            disabled: isSubmitting
+          }
+        )
+      ] }),
+      asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : null,
+    error && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("p", { className: cn("text-sm text-destructive", classNames?.error), role: "alert", children: error })
+  ] });
+  if (asDialog) {
+    return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Dialog, { open, onOpenChange: handleClose, children: /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(DialogContent, { className: cn(classNames?.dialog), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(DialogHeader, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(DialogTitle, { children: "Add signer" }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(DialogDescription, { children: "Add a new signer to this wallet." })
+      ] }),
+      formContent
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: cn(className, classNames?.root), "data-cilantro-add-signer-form": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("h3", { className: "text-sm font-medium mb-2", children: "Add signer" }),
+    formContent
+  ] });
+}
+
+// src/components/SignerList.tsx
+var import_react13 = require("react");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+function SignerList({
+  walletId,
+  className,
+  classNames,
+  onSignerAdded,
+  children
+}) {
+  const { signers, isLoading, error, refresh } = useSigners({ walletId });
+  const [addSignerOpen, setAddSignerOpen] = (0, import_react13.useState)(false);
+  const handleAddSuccess = () => {
+    refresh();
+    onSignerAdded?.();
+  };
+  if (children) {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
+      children({
+        signers,
+        isLoading,
+        error,
+        refresh,
+        openAddSigner: () => setAddSignerOpen(true)
+      }),
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        AddSignerForm,
+        {
+          walletId,
+          open: addSignerOpen,
+          onOpenChange: setAddSignerOpen,
+          onSuccess: handleAddSuccess,
+          asDialog: true
+        }
+      )
+    ] });
+  }
+  if (!walletId) {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: cn(className, classNames?.root), "data-cilantro-signer-list": true, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Select a wallet first." }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("div", { className: cn(className, classNames?.root), "data-cilantro-signer-list": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("div", { className: cn("flex items-center justify-between gap-2 mb-2", classNames?.header), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "text-sm font-medium", children: "Signers" }),
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          variant: "outline",
+          className: classNames?.addButton,
+          onClick: () => setAddSignerOpen(true),
+          disabled: isLoading,
+          children: "Add signer"
+        }
+      )
+    ] }),
+    isLoading ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading signers..." }) : error ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { className: cn("text-sm text-destructive", classNames?.message), role: "alert", children: error }) : signers.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No signers. Add one to get started." }) : /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("ul", { className: cn("space-y-1", classNames?.list), role: "list", children: signers.map((signer) => /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("li", { className: cn("text-sm", classNames?.item), children: [
+      getSignerDisplayName(signer),
+      " (",
+      getSignerTypeLabel(signer.type || signer.signerType || ""),
+      ")"
+    ] }, signer.id)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      AddSignerForm,
+      {
+        walletId,
+        open: addSignerOpen,
+        onOpenChange: setAddSignerOpen,
+        onSuccess: handleAddSuccess,
+        asDialog: true
+      }
+    )
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddSignerForm,
+  AuthForm,
+  AuthGuard,
+  CilantroAuthProvider,
+  CilantroProvider,
+  DelegatedKeySelector,
+  LoginForm,
+  MessageSigningForm,
+  RegisterForm,
+  SIGNER_TYPES,
+  SignerList,
+  SignerSelector,
+  TransactionSigningForm,
+  WalletProvider,
+  WalletSelector,
+  extractErrorMessage,
+  extractResponseData,
+  getSignerPublicKey,
+  getWalletData,
+  signAndSendTransactionWithSigner,
+  signMessageWithSigner,
+  signTransactionWithSigner,
+  useCilantroAuth,
+  useMessageSigning,
+  useSignerSelection,
+  useSigners,
+  useTransactionSigning,
+  useWallets
+});
+//# sourceMappingURL=index.js.map