cilantro-react 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2837 @@
+'use client';
+
+// src/providers/CilantroProvider.tsx
+import { useEffect as useEffect3 } from "react";
+
+// src/providers/CilantroAuthProvider.tsx
+import { createContext, useContext, useEffect, useState } from "react";
+import { clearAuth } from "cilantro-sdk";
+import { login as cilantroLogin } from "cilantro-sdk/auth";
+import { create as createUser } from "cilantro-sdk/user";
+
+// src/core/auth.ts
+import { setAuth } from "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;
+  }
+  setAuth(authPayload);
+}
+function setSdkAuth(jwt) {
+  const authConfig = {};
+  if (jwt) {
+    authConfig.jwt = jwt;
+  }
+  if (platformApiKey) {
+    authConfig.platformApiKey = platformApiKey;
+  }
+  if (apiUrl) {
+    authConfig.apiUrl = apiUrl;
+  }
+  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
+import { jsx } from "react/jsx-runtime";
+var AuthContext = 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] = useState(null);
+  const [token, setToken] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  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 cilantroLogin({ 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 createUser(userData);
+      await login(username, password);
+      onRegisterSuccess?.();
+    } catch (error) {
+      throw new Error(extractErrorMessage(error));
+    }
+  };
+  const logout = () => {
+    setUser(null);
+    setToken(null);
+    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__ */ jsx(AuthContext.Provider, { value, children });
+}
+function useCilantroAuth() {
+  const context = useContext(AuthContext);
+  if (context === void 0) {
+    throw new Error("useCilantroAuth must be used within a CilantroAuthProvider");
+  }
+  return context;
+}
+
+// src/providers/WalletProvider.tsx
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useState as useState2 } from "react";
+import { findAll as findAllWallets } from "cilantro-sdk/wallet";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var WalletContext = createContext2(void 0);
+var DEFAULT_STORAGE_KEY = "cilantro_selected_wallet_id";
+function WalletProvider({ children, storageKey = DEFAULT_STORAGE_KEY }) {
+  const { token } = useCilantroAuth();
+  const [wallets, setWallets] = useState2([]);
+  const [selectedWallet, setSelectedWallet] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  useEffect2(() => {
+    if (token) {
+      loadWallets();
+    } else {
+      setWallets([]);
+      setSelectedWallet(null);
+      setIsLoading(false);
+    }
+  }, [token]);
+  useEffect2(() => {
+    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 findAllWallets();
+      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__ */ jsx2(WalletContext.Provider, { value, children });
+}
+function useWallets() {
+  const context = useContext2(WalletContext);
+  if (context === void 0) {
+    throw new Error("useWallets must be used within a WalletProvider");
+  }
+  return context;
+}
+
+// src/core/storage-adapter.ts
+import { createIndexedDBAdapter } from "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 = 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 = createIndexedDBAdapter();
+  return storageAdapterInstance;
+}
+
+// src/providers/CilantroProvider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CilantroProvider({
+  children,
+  platformApiKey: platformApiKey2,
+  apiUrl: apiUrl2,
+  jwtStorageKey,
+  walletStorageKey,
+  onLoginSuccess,
+  onLogout,
+  onRegisterSuccess
+}) {
+  useEffect3(() => {
+    initializeStorageAdapter().catch((err) => {
+      console.error("[CilantroProvider] Failed to initialize storage adapter:", err);
+    });
+  }, []);
+  return /* @__PURE__ */ jsx3(
+    CilantroAuthProvider,
+    {
+      platformApiKey: platformApiKey2,
+      apiUrl: apiUrl2,
+      jwtStorageKey,
+      onLoginSuccess,
+      onLogout,
+      onRegisterSuccess,
+      children: /* @__PURE__ */ jsx3(WalletProvider, { storageKey: walletStorageKey, children })
+    }
+  );
+}
+
+// src/hooks/useSigners.ts
+import { useState as useState3, useEffect as useEffect4, useCallback } from "react";
+
+// src/core/signer-helpers.ts
+import { getSigners, parseSignerResponse } from "cilantro-sdk/helpers";
+import { listSigners } from "cilantro-sdk/wallet";
+async function loadSigners(walletId) {
+  if (!walletId) return [];
+  try {
+    let signersResult = await 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 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 = 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] = useState3([]);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const load = 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]);
+  useEffect4(() => {
+    const id = walletIdOption ?? void 0;
+    if (id) load(id);
+    else {
+      setSigners([]);
+      setError(null);
+    }
+  }, [walletIdOption, load]);
+  const refresh = useCallback(async () => {
+    const id = walletIdOption ?? void 0;
+    if (id) await load(id);
+  }, [walletIdOption, load]);
+  return { signers, isLoading, error, refresh };
+}
+
+// src/hooks/useSignerSelection.ts
+import { useState as useState4, useEffect as useEffect5, useCallback as useCallback2 } from "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] = useState4(effectiveWalletId);
+  const [selectedSigner, setSelectedSigner] = useState4(null);
+  useEffect5(() => {
+    setSelectedWalletId(effectiveWalletId);
+  }, [effectiveWalletId]);
+  useEffect5(() => {
+    if (signingMethod !== "sdk-signer") {
+      setSelectedSigner(null);
+    }
+  }, [signingMethod]);
+  const reset = useCallback2(() => {
+    setSelectedWalletId("");
+    setSelectedSigner(null);
+  }, []);
+  return {
+    selectedWalletId: selectedWalletId || effectiveWalletId,
+    setSelectedWalletId,
+    availableSigners,
+    selectedSigner,
+    setSelectedSigner,
+    isLoadingSigners,
+    reset
+  };
+}
+
+// src/hooks/useMessageSigning.ts
+import { useState as useState5 } from "react";
+
+// src/core/signer-signing/core.ts
+import { PublicKey } from "@solana/web3.js";
+import {
+  deriveSignerKeypair,
+  getEmailSignerKeypair,
+  getPhoneSignerKeypair
+} from "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 PublicKey(existingPubkey.trim());
+  }
+  const storageOptions = getStorageOptions();
+  if (signerType === SIGNER_TYPES.EMAIL) {
+    const keypair = await getEmailSignerKeypair(walletId, signerId, storageOptions);
+    return new PublicKey(keypair.publicKey);
+  }
+  if (signerType === SIGNER_TYPES.PHONE) {
+    const keypair = await getPhoneSignerKeypair(walletId, signerId, storageOptions);
+    return new PublicKey(keypair.publicKey);
+  }
+  if (signerType === SIGNER_TYPES.EXTERNAL || signerType === SIGNER_TYPES.API_KEY) {
+    const keypair = await deriveSignerKeypair(walletId, signerId, signerType, storageOptions);
+    return new PublicKey(keypair.publicKey);
+  }
+  throw new Error(`Unsupported signer type: ${signerType}`);
+}
+
+// src/core/signer-signing/message-signing.ts
+import {
+  deriveSignerKeypair as deriveSignerKeypair2,
+  signWithSigner,
+  signWithEmailSigner,
+  signWithPhoneSigner,
+  getEmailSignerKeypair as getEmailSignerKeypair2,
+  getPhoneSignerKeypair as getPhoneSignerKeypair2
+} from "cilantro-sdk/helpers";
+
+// src/core/signer-creation.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import {
+  createEmailSignerHelper as createEmailSignerSDK,
+  createPhoneSignerHelper as createPhoneSignerSDK,
+  isValidEmail,
+  isValidPhone,
+  authenticateWithPasskey,
+  findExistingPasskeySigner,
+  formatAuthenticationResponse,
+  isWebAuthnSupported,
+  registerPasskeyComplete,
+  signWithPasskeySigner
+} from "cilantro-sdk/helpers";
+import { sendRawPasskeyTransaction } from "cilantro-sdk/transactions";
+import { createExternalWalletSigner, startPasskeyAuthentication } from "cilantro-sdk/wallet";
+async function createEmailSignerHelper(walletId, email) {
+  const trimmedEmail = email.trim();
+  if (!trimmedEmail) throw new Error("Email address is required");
+  if (!isValidEmail(trimmedEmail)) throw new Error("Invalid email address format");
+  const deviceKeyManager = getStorageAdapter();
+  return await createEmailSignerSDK(walletId, { email: trimmedEmail, deviceKeyManager });
+}
+async function createPhoneSignerHelper(walletId, phone) {
+  const trimmedPhone = phone.trim();
+  if (!trimmedPhone) throw new Error("Phone number is required");
+  if (!isValidPhone(trimmedPhone)) throw new Error("Invalid phone number format");
+  const deviceKeyManager = getStorageAdapter();
+  return await createPhoneSignerSDK(walletId, { phone: trimmedPhone, deviceKeyManager });
+}
+async function createExternalSignerHelper(walletId, address) {
+  if (!address.trim()) throw new Error("Wallet address is required");
+  return await createExternalWalletSigner(walletId, { address: address.trim(), chain: "solana" });
+}
+async function registerPasskeySigner(walletId) {
+  if (!isWebAuthnSupported()) throw new Error("WebAuthn is not supported in this browser");
+  return await registerPasskeyComplete(walletId);
+}
+async function signWithPasskey(walletId, signerId, message, options) {
+  if (!isWebAuthnSupported()) throw new Error("WebAuthn is not supported in this browser");
+  const messageBytes = new TextEncoder().encode(message);
+  const signature = await signWithPasskeySigner(walletId, signerId, messageBytes, options);
+  return {
+    signature: Buffer.from(signature).toString("hex"),
+    signer: signerId
+  };
+}
+async function signAndSendPasskeyTransaction(walletId, signerId, transaction, options) {
+  if (!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 PublicKey2("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 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 authenticateWithPasskey(
+    authDataValue,
+    { useBrowserAutofill: options?.useBrowserAutofill ?? false }
+  );
+  const formattedCredential = formatAuthenticationResponse(credential);
+  const dto = {
+    walletId,
+    credentialId,
+    unsignedTransaction,
+    signature: formattedCredential.response.signature,
+    authenticatorData: formattedCredential.response.authenticatorData,
+    clientDataJSON: formattedCredential.response.clientDataJSON
+  };
+  const result = await sendRawPasskeyTransaction(dto);
+  const resultData = extractResponseData(result);
+  return { signature: resultData?.signature ?? "", status: resultData?.status };
+}
+
+// src/core/signer-signing/errors.ts
+import {
+  DeviceKeyNotFoundError,
+  DeviceKeyMismatchError,
+  SignerInactiveError,
+  SignerNotFoundError
+} from "cilantro-sdk/helpers";
+function handleDeviceKeyError(error, signerType) {
+  if (error instanceof 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 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 SignerNotFoundError) {
+    throw new Error(`Signer not found. Please ensure the ${signerType} signer exists.`);
+  }
+  if (error instanceof 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 signWithEmailSigner(walletId, signerId, message, storageOptions);
+      const keypair = await getEmailSignerKeypair2(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 signWithPhoneSigner(walletId, signerId, message, storageOptions);
+      const keypair = await getPhoneSignerKeypair2(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 signWithSigner(walletId, signerId, signerType, message, storageOptions);
+    const keypair = await deriveSignerKeypair2(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
+import {
+  signWithSigner as signWithSigner2,
+  signWithEmailSigner as signWithEmailSigner2,
+  signWithPhoneSigner as signWithPhoneSigner2,
+  signTransactionWithEmailSigner,
+  signTransactionWithPhoneSigner
+} from "cilantro-sdk/helpers";
+import { submitTransaction } from "cilantro-sdk/wallet";
+
+// src/core/signer-signing/validation.ts
+import { PublicKey as PublicKey3, Transaction } from "@solana/web3.js";
+async function validateSignerInTransaction(signedTransactionBase64, expectedSignerPublicKey) {
+  const errors = [];
+  const warnings = [];
+  try {
+    const transactionBuffer = Buffer.from(signedTransactionBase64, "base64");
+    const transaction = 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 PublicKey3(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 PublicKey3(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 signTransactionWithEmailSigner(
+      walletId,
+      signerId,
+      unsignedTransactionBase64,
+      storageOptions
+    );
+  }
+  return await signTransactionWithPhoneSigner(
+    walletId,
+    signerId,
+    unsignedTransactionBase64,
+    storageOptions
+  );
+}
+async function submitSignedTransaction(walletId, signedTransactionBase64) {
+  const submitResult = await 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 signWithSigner2(
+    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 signWithEmailSigner2(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 signWithPhoneSigner2(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 signWithSigner2(
+      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
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+import { findOne as findOneWallet } from "cilantro-sdk/wallet";
+async function getWalletData(walletId) {
+  const walletDataResponse = await findOneWallet(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 PublicKey4(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 PublicKey4(adminPubkey);
+  return { walletPublicKey, adminSignerPubkey };
+}
+
+// src/hooks/useMessageSigning.ts
+function useMessageSigning(options) {
+  const {
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignMessage,
+    walletAdapterPublicKey
+  } = options;
+  const [messageText, setMessageText] = useState5("Hello, Solana!");
+  const [signResultState, setSignResultState] = useState5({ status: "idle" });
+  const [isSigning, setIsSigning] = useState5(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
+import { useState as useState6 } from "react";
+function useTransactionSigning(options) {
+  const {
+    token,
+    signingMethod,
+    selectedSigner,
+    selectedWalletId,
+    walletAdapterSignTransaction,
+    walletAdapterPublicKey,
+    connection
+  } = options;
+  const [transactionResultState, setTransactionResultState] = useState6({ status: "idle" });
+  const [isSigningTransaction, setIsSigningTransaction] = useState6(false);
+  const [isSendingTransaction, setIsSendingTransaction] = useState6(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
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+
+// src/ui/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/ui/select.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var Select = SelectPrimitive.Root;
+var SelectValue = SelectPrimitive.Value;
+var SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ 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__ */ jsx4(SelectPrimitive.Icon, { asChild: true, children: /* @__PURE__ */ jsx4("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__ */ jsx4(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsx4(
+  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__ */ jsx4(
+      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__ */ 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__ */ jsx4("span", { className: "absolute right-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx4(SelectPrimitive.ItemIndicator, { children: "\u2713" }) }),
+      /* @__PURE__ */ jsx4(SelectPrimitive.ItemText, { children })
+    ]
+  }
+));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+
+// src/components/WalletSelector.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "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__ */ jsx5(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__ */ jsxs2("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__ */ jsx5("div", { className: cn(className, classNames?.root), "data-cilantro-wallet-selector": true, children: /* @__PURE__ */ jsxs2(Select, { value: effectiveValue || void 0, onValueChange: handleValueChange, disabled: isLoading, children: [
+    /* @__PURE__ */ jsx5(SelectTrigger, { className: classNames?.trigger, "aria-label": "Select wallet", children: /* @__PURE__ */ jsx5(SelectValue, { placeholder: isLoading ? "Loading..." : placeholder }) }),
+    /* @__PURE__ */ jsx5(SelectContent, { className: classNames?.content, children: wallets.map((w) => /* @__PURE__ */ jsx5(SelectItem, { value: w.id, className: classNames?.item, children: w.walletName || w.id }, w.id)) })
+  ] }) });
+}
+
+// src/ui/button.tsx
+import * as React2 from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var buttonVariants = 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 ? Slot : "button";
+    return /* @__PURE__ */ jsx6(Comp, { className: cn(buttonVariants({ variant, size, className })), ref, ...props });
+  }
+);
+Button.displayName = "Button";
+
+// src/components/SignerSelector.tsx
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+function SignerSelector({
+  selectedWalletId,
+  availableSigners,
+  selectedSigner,
+  isLoadingSigners = false,
+  onSignerSelect,
+  className,
+  classNames,
+  renderList,
+  children
+}) {
+  if (!selectedWalletId) return null;
+  if (children) {
+    return /* @__PURE__ */ jsx7(Fragment2, { children: children({ signers: availableSigners, selectedSigner, onSignerSelect, isLoading: isLoadingSigners }) });
+  }
+  if (renderList) {
+    return /* @__PURE__ */ jsx7("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__ */ jsx7("div", { className: cn(className, classNames?.root), "data-cilantro-signer-selector": true, role: "listbox", "aria-label": "Select signer", children: isLoadingSigners ? /* @__PURE__ */ jsx7("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading signers..." }) : availableSigners.length === 0 ? /* @__PURE__ */ jsx7("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No signers for this wallet." }) : /* @__PURE__ */ jsx7("ul", { className: cn("space-y-1", classNames?.list), children: availableSigners.map((signer) => /* @__PURE__ */ jsx7("li", { children: /* @__PURE__ */ jsxs3(
+    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
+import { useState as useState7, useEffect as useEffect6, useCallback as useCallback3 } from "react";
+import { findAll } from "cilantro-sdk/delegated-keys";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs4 } from "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] = useState7([]);
+  const [isLoading, setIsLoading] = useState7(false);
+  const [error, setError] = useState7(null);
+  const loadKeys = useCallback3(async () => {
+    if (!walletId) {
+      setKeys([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (token) setSdkAuth(token);
+      const result = await 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]);
+  useEffect6(() => {
+    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__ */ jsx8(Fragment3, { children: children({ keys, selectedKeyId: value, onSelect, isLoading, error, refresh: loadKeys }) });
+  }
+  if (!walletId) {
+    return /* @__PURE__ */ jsx8("div", { className: cn(className, classNames?.root, "text-sm text-muted-foreground"), children: "Select a wallet first" });
+  }
+  return /* @__PURE__ */ jsx8("div", { className: cn(className, classNames?.root), "data-cilantro-delegated-key-selector": true, children: isLoading ? /* @__PURE__ */ jsx8("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading delegated keys..." }) : error ? /* @__PURE__ */ jsx8("p", { className: cn("text-sm text-destructive", classNames?.message), role: "alert", children: error }) : keys.length === 0 ? /* @__PURE__ */ jsx8("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No delegated keys found." }) : /* @__PURE__ */ jsxs4(Select, { value: (value ?? "") || void 0, onValueChange: handleValueChange, children: [
+    /* @__PURE__ */ jsx8(SelectTrigger, { className: classNames?.trigger, "aria-label": "Select delegated key", children: /* @__PURE__ */ jsx8(SelectValue, { placeholder }) }),
+    /* @__PURE__ */ jsx8(SelectContent, { className: classNames?.content, children: keys.map((k) => /* @__PURE__ */ jsx8(SelectItem, { value: k.id, className: classNames?.item, children: k.name || k.publicKey.slice(0, 8) + "..." }, k.id)) })
+  ] }) });
+}
+
+// src/ui/textarea.tsx
+import * as React3 from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var Textarea = React3.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx9(
+    "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
+import * as React4 from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { cva as cva2 } from "class-variance-authority";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var labelVariants = cva2(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label = React4.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx10(LabelPrimitive.Root, { ref, className: cn(labelVariants(), className), ...props }));
+Label.displayName = LabelPrimitive.Root.displayName;
+
+// src/ui/card.tsx
+import * as React5 from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var Card = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx11(
+    "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__ */ jsx11("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__ */ jsx11(
+    "h3",
+    {
+      ref,
+      className: cn("font-semibold leading-none tracking-tight", className),
+      ...props
+    }
+  )
+);
+CardTitle.displayName = "CardTitle";
+var CardDescription = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx11("p", { ref, className: cn("text-sm text-muted-foreground", className), ...props }));
+CardDescription.displayName = "CardDescription";
+var CardContent = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx11("div", { ref, className: cn("p-6 pt-0", className), ...props })
+);
+CardContent.displayName = "CardContent";
+var CardFooter = React5.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx11("div", { ref, className: cn("flex items-center p-6 pt-0", className), ...props })
+);
+CardFooter.displayName = "CardFooter";
+
+// src/components/MessageSigningForm.tsx
+import { jsx as jsx12, jsxs as jsxs5 } from "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__ */ jsx12("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__ */ jsxs5(Card, { className: cn(className, classNames?.root), "data-cilantro-message-signing-form": true, children: [
+    /* @__PURE__ */ jsxs5(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ jsx12(CardTitle, { className: cn("text-lg", classNames?.title), children: "Sign message" }),
+      /* @__PURE__ */ jsx12(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__ */ jsxs5("p", { className: cn("mt-1 text-xs text-muted-foreground", classNames?.context), children: [
+        selectedWalletId && /* @__PURE__ */ jsxs5("span", { children: [
+          "Wallet: ",
+          selectedWalletId.slice(0, 8),
+          "\u2026"
+        ] }),
+        selectedSigner && /* @__PURE__ */ jsxs5("span", { className: selectedWalletId ? " ml-2" : "", children: [
+          "Signer: ",
+          getSignerDisplayName(selectedSigner),
+          " (",
+          getSignerTypeLabel(selectedSigner.type || selectedSigner.signerType || ""),
+          ")"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs5(CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxs5("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx12(Label, { htmlFor: "cilantro-message-text", className: classNames?.label, children: "Message" }),
+        /* @__PURE__ */ jsx12(
+          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__ */ jsxs5("p", { className: cn("text-right text-xs text-muted-foreground", classNames?.charCount), children: [
+          signing.messageText.length,
+          " character",
+          signing.messageText.length !== 1 ? "s" : ""
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs5("div", { className: "flex flex-col gap-2 sm:flex-row sm:items-center", children: [
+        /* @__PURE__ */ jsx12(
+          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__ */ jsx12(
+          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__ */ jsxs5(
+        "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__ */ jsx12("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
+import { jsx as jsx13, jsxs as jsxs6 } from "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__ */ jsx13("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__ */ jsxs6(Card, { className: cn(className, classNames?.root), "data-cilantro-transaction-signing-form": true, children: [
+    /* @__PURE__ */ jsxs6(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ jsx13(CardTitle, { className: cn("text-lg", classNames?.title), children: "Sign transaction" }),
+      /* @__PURE__ */ jsxs6(CardDescription, { className: classNames?.description, children: [
+        "Build a transaction in your app, then pass it to ",
+        /* @__PURE__ */ jsx13("code", { className: "text-xs", children: "signTransaction(tx)" }),
+        " to sign only, or ",
+        /* @__PURE__ */ jsx13("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__ */ jsxs6("p", { className: cn("mt-1 text-xs text-muted-foreground", classNames?.context), children: [
+        selectedWalletId && /* @__PURE__ */ jsxs6("span", { children: [
+          "Wallet: ",
+          selectedWalletId.slice(0, 8),
+          "\u2026"
+        ] }),
+        selectedSigner && /* @__PURE__ */ jsxs6("span", { className: selectedWalletId ? " ml-2" : "", children: [
+          "Signer: ",
+          getSignerDisplayName(selectedSigner),
+          " (",
+          getSignerTypeLabel(selectedSigner.type || selectedSigner.signerType || ""),
+          ")"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ jsx13(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          className: classNames?.button,
+          onClick: signing.reset,
+          disabled: signing.isSigningTransaction || signing.isSendingTransaction,
+          children: "Reset status"
+        }
+      ),
+      resultStatus !== "idle" && /* @__PURE__ */ jsxs6(
+        "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__ */ jsx13("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
+import { useState as useState8 } from "react";
+
+// src/ui/input.tsx
+import * as React6 from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var Input = React6.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsx14(
+      "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
+import { jsx as jsx15, jsxs as jsxs7 } from "react/jsx-runtime";
+function LoginForm({
+  className,
+  classNames,
+  onSuccess,
+  onError,
+  submitLabel = "Sign in",
+  title = "Sign in",
+  description,
+  renderSwitchToRegister
+}) {
+  const { login, isLoading } = useCilantroAuth();
+  const [usernameOrEmail, setUsernameOrEmail] = useState8("");
+  const [password, setPassword] = useState8("");
+  const [error, setError] = useState8(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__ */ jsxs7(Card, { className: cn(className, classNames?.root), "data-cilantro-login-form": true, children: [
+    /* @__PURE__ */ jsxs7(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ jsx15(CardTitle, { className: classNames?.title, children: title }),
+      description != null && /* @__PURE__ */ jsx15(CardDescription, { className: classNames?.description, children: description })
+    ] }),
+    /* @__PURE__ */ jsx15(CardContent, { children: /* @__PURE__ */ jsxs7("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx15(Label, { htmlFor: "cilantro-login-username", className: classNames?.label, children: "Username or email" }),
+        /* @__PURE__ */ jsx15(
+          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__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx15(Label, { htmlFor: "cilantro-login-password", className: classNames?.label, children: "Password" }),
+        /* @__PURE__ */ jsx15(
+          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__ */ jsx15(
+        "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__ */ jsx15(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !usernameOrEmail.trim() || !password,
+          children: isLoading ? "Signing in..." : submitLabel
+        }
+      ),
+      renderSwitchToRegister && /* @__PURE__ */ jsx15("div", { className: "text-center text-sm text-muted-foreground", children: renderSwitchToRegister() })
+    ] }) })
+  ] });
+}
+
+// src/components/RegisterForm.tsx
+import { useState as useState9 } from "react";
+import { jsx as jsx16, jsxs as jsxs8 } from "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] = useState9("");
+  const [email, setEmail] = useState9("");
+  const [password, setPassword] = useState9("");
+  const [error, setError] = useState9(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__ */ jsxs8(Card, { className: cn(className, classNames?.root), "data-cilantro-register-form": true, children: [
+    /* @__PURE__ */ jsxs8(CardHeader, { className: classNames?.header, children: [
+      /* @__PURE__ */ jsx16(CardTitle, { className: classNames?.title, children: title }),
+      description != null && /* @__PURE__ */ jsx16(CardDescription, { className: classNames?.description, children: description })
+    ] }),
+    /* @__PURE__ */ jsx16(CardContent, { children: /* @__PURE__ */ jsxs8("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      /* @__PURE__ */ jsxs8("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx16(Label, { htmlFor: "cilantro-register-username", className: classNames?.label, children: "Username" }),
+        /* @__PURE__ */ jsx16(
+          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__ */ jsxs8("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx16(Label, { htmlFor: "cilantro-register-email", className: classNames?.label, children: "Email" }),
+        /* @__PURE__ */ jsx16(
+          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__ */ jsxs8("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx16(Label, { htmlFor: "cilantro-register-password", className: classNames?.label, children: "Password" }),
+        /* @__PURE__ */ jsx16(
+          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__ */ jsx16(
+        "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__ */ jsx16(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !username.trim() || !email.trim() || !password,
+          children: isLoading ? "Creating account..." : submitLabel
+        }
+      ),
+      renderSwitchToLogin && /* @__PURE__ */ jsx16("div", { className: "text-center text-sm text-muted-foreground", children: renderSwitchToLogin() })
+    ] }) })
+  ] });
+}
+
+// src/components/AuthForm.tsx
+import { useState as useState10 } from "react";
+import { Fragment as Fragment4, jsx as jsx17, jsxs as jsxs9 } from "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] = useState10(defaultMode);
+  const [usernameOrEmail, setUsernameOrEmail] = useState10("");
+  const [username, setUsername] = useState10("");
+  const [email, setEmail] = useState10("");
+  const [password, setPassword] = useState10("");
+  const [error, setError] = useState10(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__ */ jsxs9(Card, { className: cn("w-full max-w-sm", className, classNames?.root), "data-cilantro-auth-form": true, children: [
+    /* @__PURE__ */ jsxs9(CardHeader, { className: cn("space-y-1 text-center sm:text-left", classNames?.header), children: [
+      /* @__PURE__ */ jsx17(CardTitle, { className: cn("text-xl", classNames?.title), children: isLogin ? loginTitle : registerTitle }),
+      /* @__PURE__ */ jsx17(CardDescription, { className: classNames?.description, children: isLogin ? loginDescription : registerDescription })
+    ] }),
+    /* @__PURE__ */ jsx17(CardContent, { children: /* @__PURE__ */ jsxs9("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+      isLogin ? /* @__PURE__ */ jsxs9(Fragment4, { children: [
+        /* @__PURE__ */ jsxs9("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx17(Label, { htmlFor: "cilantro-auth-username", className: classNames?.label, children: "Username or email" }),
+          /* @__PURE__ */ jsx17(
+            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__ */ jsxs9("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx17(Label, { htmlFor: "cilantro-auth-password", className: classNames?.label, children: "Password" }),
+          /* @__PURE__ */ jsx17(
+            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__ */ jsxs9(Fragment4, { children: [
+        /* @__PURE__ */ jsxs9("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx17(Label, { htmlFor: "cilantro-auth-reg-username", className: classNames?.label, children: "Username" }),
+          /* @__PURE__ */ jsx17(
+            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__ */ jsxs9("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx17(Label, { htmlFor: "cilantro-auth-reg-email", className: classNames?.label, children: "Email" }),
+          /* @__PURE__ */ jsx17(
+            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__ */ jsxs9("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx17(Label, { htmlFor: "cilantro-auth-reg-password", className: classNames?.label, children: "Password" }),
+          /* @__PURE__ */ jsx17(
+            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__ */ jsx17(
+        "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__ */ jsx17(
+        Button,
+        {
+          type: "submit",
+          className: cn("w-full", classNames?.submitButton),
+          disabled: isLoading || !canSubmit,
+          children: isLoading ? isLogin ? "Signing in..." : "Creating account..." : isLogin ? loginSubmitLabel : registerSubmitLabel
+        }
+      ),
+      /* @__PURE__ */ jsx17("p", { className: cn("text-center text-sm text-muted-foreground", classNames?.toggle), children: /* @__PURE__ */ jsx17(
+        "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
+import { Fragment as Fragment5, jsx as jsx18 } from "react/jsx-runtime";
+function AuthGuard({
+  children,
+  fallback,
+  className,
+  classNames,
+  showFallback = true
+}) {
+  const { isAuthenticated, isLoading } = useCilantroAuth();
+  if (isLoading) {
+    return /* @__PURE__ */ jsx18("div", { className: cn(className, classNames?.root), "data-cilantro-auth-guard": true, children: /* @__PURE__ */ jsx18("div", { className: cn("text-sm text-muted-foreground", classNames?.fallback), children: "Loading..." }) });
+  }
+  if (!isAuthenticated) {
+    if (!showFallback) return null;
+    return /* @__PURE__ */ jsx18("div", { className: cn(className, classNames?.root), "data-cilantro-auth-guard": true, children: fallback ?? /* @__PURE__ */ jsx18(LoginForm, { className: classNames?.fallback }) });
+  }
+  return /* @__PURE__ */ jsx18(Fragment5, { children });
+}
+
+// src/components/AddSignerForm.tsx
+import { useState as useState11 } from "react";
+
+// src/ui/dialog.tsx
+import * as React7 from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { jsx as jsx19, jsxs as jsxs10 } from "react/jsx-runtime";
+var Dialog = DialogPrimitive.Root;
+var DialogPortal = DialogPrimitive.Portal;
+var DialogOverlay = React7.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx19(
+  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__ */ jsxs10(DialogPortal, { children: [
+  /* @__PURE__ */ jsx19(DialogOverlay, {}),
+  /* @__PURE__ */ jsx19(
+    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__ */ jsx19("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__ */ jsx19(
+  "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__ */ jsx19(
+  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__ */ jsx19(
+  DialogPrimitive.Description,
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+
+// src/components/AddSignerForm.tsx
+import { Fragment as Fragment6, jsx as jsx20, jsxs as jsxs11 } from "react/jsx-runtime";
+function AddSignerForm({
+  walletId,
+  open = true,
+  onOpenChange,
+  onSuccess,
+  onCancel,
+  onError,
+  className,
+  classNames,
+  asDialog = true
+}) {
+  const [signerType, setSignerType] = useState11(null);
+  const [email, setEmail] = useState11("");
+  const [phone, setPhone] = useState11("");
+  const [address, setAddress] = useState11("");
+  const [isSubmitting, setIsSubmitting] = useState11(false);
+  const [error, setError] = useState11(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__ */ jsxs11("form", { onSubmit: handleSubmit, className: cn("space-y-4", classNames?.form), children: [
+    !signerType ? /* @__PURE__ */ jsxs11(Fragment6, { children: [
+      /* @__PURE__ */ jsxs11("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx20(Label, { className: classNames?.label, children: "Signer type" }),
+        /* @__PURE__ */ jsxs11("div", { className: "flex flex-wrap gap-2", children: [
+          /* @__PURE__ */ jsx20(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("email"),
+              disabled: isSubmitting,
+              children: "Email"
+            }
+          ),
+          /* @__PURE__ */ jsx20(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("phone"),
+              disabled: isSubmitting,
+              children: "Phone"
+            }
+          ),
+          /* @__PURE__ */ jsx20(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: handlePasskeyClick,
+              disabled: isSubmitting,
+              children: "Passkey"
+            }
+          ),
+          /* @__PURE__ */ jsx20(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => setSignerType("external"),
+              disabled: isSubmitting,
+              children: "External wallet"
+            }
+          )
+        ] })
+      ] }),
+      asDialog && /* @__PURE__ */ jsx20(DialogFooter, { className: "gap-2 sm:gap-0", children: /* @__PURE__ */ jsx20(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          className: classNames?.cancelButton,
+          onClick: () => handleClose(false),
+          disabled: isSubmitting,
+          children: "Cancel"
+        }
+      ) })
+    ] }) : signerType === "email" ? /* @__PURE__ */ jsxs11(Fragment6, { children: [
+      /* @__PURE__ */ jsxs11("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx20(Label, { htmlFor: "add-signer-email", className: classNames?.label, children: "Email" }),
+        /* @__PURE__ */ jsx20(
+          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__ */ jsxs11(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ jsxs11("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : signerType === "phone" ? /* @__PURE__ */ jsxs11(Fragment6, { children: [
+      /* @__PURE__ */ jsxs11("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx20(Label, { htmlFor: "add-signer-phone", className: classNames?.label, children: "Phone number" }),
+        /* @__PURE__ */ jsx20(
+          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__ */ jsxs11(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ jsxs11("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : signerType === "external" ? /* @__PURE__ */ jsxs11(Fragment6, { children: [
+      /* @__PURE__ */ jsxs11("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx20(Label, { htmlFor: "add-signer-address", className: classNames?.label, children: "Wallet address" }),
+        /* @__PURE__ */ jsx20(
+          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__ */ jsxs11(DialogFooter, { className: "gap-2 sm:gap-0", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] }),
+      !asDialog && /* @__PURE__ */ jsxs11("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ jsx20(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            className: classNames?.cancelButton,
+            onClick: () => setSignerType(null),
+            disabled: isSubmitting,
+            children: "Back"
+          }
+        ),
+        /* @__PURE__ */ jsx20(Button, { type: "submit", className: classNames?.submitButton, disabled: isSubmitting, children: isSubmitting ? "Adding..." : "Add signer" })
+      ] })
+    ] }) : null,
+    error && /* @__PURE__ */ jsx20("p", { className: cn("text-sm text-destructive", classNames?.error), role: "alert", children: error })
+  ] });
+  if (asDialog) {
+    return /* @__PURE__ */ jsx20(Dialog, { open, onOpenChange: handleClose, children: /* @__PURE__ */ jsxs11(DialogContent, { className: cn(classNames?.dialog), children: [
+      /* @__PURE__ */ jsxs11(DialogHeader, { children: [
+        /* @__PURE__ */ jsx20(DialogTitle, { children: "Add signer" }),
+        /* @__PURE__ */ jsx20(DialogDescription, { children: "Add a new signer to this wallet." })
+      ] }),
+      formContent
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs11("div", { className: cn(className, classNames?.root), "data-cilantro-add-signer-form": true, children: [
+    /* @__PURE__ */ jsx20("h3", { className: "text-sm font-medium mb-2", children: "Add signer" }),
+    formContent
+  ] });
+}
+
+// src/components/SignerList.tsx
+import { useState as useState12 } from "react";
+import { Fragment as Fragment7, jsx as jsx21, jsxs as jsxs12 } from "react/jsx-runtime";
+function SignerList({
+  walletId,
+  className,
+  classNames,
+  onSignerAdded,
+  children
+}) {
+  const { signers, isLoading, error, refresh } = useSigners({ walletId });
+  const [addSignerOpen, setAddSignerOpen] = useState12(false);
+  const handleAddSuccess = () => {
+    refresh();
+    onSignerAdded?.();
+  };
+  if (children) {
+    return /* @__PURE__ */ jsxs12(Fragment7, { children: [
+      children({
+        signers,
+        isLoading,
+        error,
+        refresh,
+        openAddSigner: () => setAddSignerOpen(true)
+      }),
+      /* @__PURE__ */ jsx21(
+        AddSignerForm,
+        {
+          walletId,
+          open: addSignerOpen,
+          onOpenChange: setAddSignerOpen,
+          onSuccess: handleAddSuccess,
+          asDialog: true
+        }
+      )
+    ] });
+  }
+  if (!walletId) {
+    return /* @__PURE__ */ jsx21("div", { className: cn(className, classNames?.root), "data-cilantro-signer-list": true, children: /* @__PURE__ */ jsx21("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Select a wallet first." }) });
+  }
+  return /* @__PURE__ */ jsxs12("div", { className: cn(className, classNames?.root), "data-cilantro-signer-list": true, children: [
+    /* @__PURE__ */ jsxs12("div", { className: cn("flex items-center justify-between gap-2 mb-2", classNames?.header), children: [
+      /* @__PURE__ */ jsx21("span", { className: "text-sm font-medium", children: "Signers" }),
+      /* @__PURE__ */ jsx21(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          variant: "outline",
+          className: classNames?.addButton,
+          onClick: () => setAddSignerOpen(true),
+          disabled: isLoading,
+          children: "Add signer"
+        }
+      )
+    ] }),
+    isLoading ? /* @__PURE__ */ jsx21("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "Loading signers..." }) : error ? /* @__PURE__ */ jsx21("p", { className: cn("text-sm text-destructive", classNames?.message), role: "alert", children: error }) : signers.length === 0 ? /* @__PURE__ */ jsx21("p", { className: cn("text-sm text-muted-foreground", classNames?.message), children: "No signers. Add one to get started." }) : /* @__PURE__ */ jsx21("ul", { className: cn("space-y-1", classNames?.list), role: "list", children: signers.map((signer) => /* @__PURE__ */ jsxs12("li", { className: cn("text-sm", classNames?.item), children: [
+      getSignerDisplayName(signer),
+      " (",
+      getSignerTypeLabel(signer.type || signer.signerType || ""),
+      ")"
+    ] }, signer.id)) }),
+    /* @__PURE__ */ jsx21(
+      AddSignerForm,
+      {
+        walletId,
+        open: addSignerOpen,
+        onOpenChange: setAddSignerOpen,
+        onSuccess: handleAddSuccess,
+        asDialog: true
+      }
+    )
+  ] });
+}
+export {
+  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.mjs.map