@embarkai/ui-kit 0.1.6 → 0.2.1

package/dist/index.js

@@ -150,7 +150,9 @@ var init_initial = __esm({
         enabled: false,
         supportedChains: [1, 137, 56],
         requireSignature: true,
-        walletConnectProjectId: void 0
+        walletConnectProjectId: void 0,
+        mode: "linked",
+        allowedWallets: void 0
       },
       // preferedColorMode: 'light', // undefined means 'auto'
       ui: {
@@ -15468,7 +15470,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@embarkai/ui-kit",
-      version: "0.1.6",
+      version: "0.2.1",
       description: "React UI components and hooks for EmbarkAI authentication and Account Abstraction",
       type: "module",
       main: "./dist/index.cjs",
@@ -16175,21 +16177,71 @@ async function unlinkWallet(address) {
     throw new Error(errorData.message || `Failed to unlink wallet: ${response.statusText}`);
   }
 }
-function createSignatureMessage(address, nonce) {
+async function fetchProjectName(projectId) {
+  const now = Date.now();
+  if (metadataCache && now - metadataCache.timestamp < METADATA_CACHE_TTL) {
+    return metadataCache.data.name;
+  }
+  try {
+    const response = await fetch(`${METADATA_API_URL}/${projectId}/metadata`);
+    if (!response.ok) return "EmbarkAI";
+    const metadata = await response.json();
+    metadataCache = { data: metadata, timestamp: now };
+    return metadata.name;
+  } catch {
+    return "EmbarkAI";
+  }
+}
+function createSignatureMessage(address, projectName, nonce) {
   const timestamp = Date.now();
   const nonceValue = nonce || Math.random().toString(36).substring(2, 15);
-  return `EmbarkAI Wallet Link
+  return `${projectName} Wallet Link
 
 Address: ${address}
 Nonce: ${nonceValue}
 Timestamp: ${timestamp}
 
-Sign this message to link your wallet to EmbarkAI Wallet`;
+Sign this message to link your wallet to ${projectName} Wallet`;
 }
+var METADATA_API_URL, METADATA_CACHE_TTL, metadataCache;
 var init_wallet = __esm({
   "src/internal/auth/providers/wallet.ts"() {
     init_auth();
     init_types();
+    METADATA_API_URL = "https://dashboard.lumiapassport.com/api/public/project";
+    METADATA_CACHE_TTL = 36e5;
+    metadataCache = null;
+  }
+});
+
+// src/internal/stores/useExternalWalletStore.ts
+import { create as create7 } from "zustand";
+var useExternalWalletStore;
+var init_useExternalWalletStore = __esm({
+  "src/internal/stores/useExternalWalletStore.ts"() {
+    useExternalWalletStore = create7((set) => ({
+      configMode: "linked",
+      activeMode: "linked",
+      externalAddress: null,
+      externalChainId: null,
+      isExternalConnected: false,
+      connectorName: null,
+      setConfigMode: (mode) => set({ configMode: mode }),
+      setActiveMode: (mode) => set({ activeMode: mode }),
+      setExternalWallet: ({ address, chainId, connectorName }) => set({
+        externalAddress: address,
+        externalChainId: chainId,
+        isExternalConnected: true,
+        connectorName
+      }),
+      clearExternalWallet: () => set({
+        externalAddress: null,
+        externalChainId: null,
+        isExternalConnected: false,
+        connectorName: null
+      }),
+      setExternalChainId: (chainId) => set({ externalChainId: chainId })
+    }));
   }
 });
 
@@ -16213,6 +16265,10 @@ function WalletConnectHandler() {
   const setManageWalletLinkError = useManageWalletStore((st) => st.setLinkError);
   const setLinkIsLoading = useManageWalletStore((st) => st.setLinkIsLoading);
   const setProviderType = useManageWalletStore((st) => st.setProviderType);
+  const providerConfig = useProviderConfig().config.current;
+  const walletMode = providerConfig?.wallet?.mode || "linked";
+  const projectId = providerConfig?.projectId;
+  const setExternalWallet = useExternalWalletStore((st) => st.setExternalWallet);
   const onLinkingComplete = useCallback23(
     async (success) => {
       setIsWalletLinking(false);
@@ -16243,24 +16299,42 @@ function WalletConnectHandler() {
   const [hasStartedLinking, setHasStartedLinking] = React8.useState(false);
   useEffect36(() => {
     if (isWalletLinking && !hasStartedLinking) {
+      console.log("[WalletConnectHandler] Starting wallet link flow:", {
+        isConnected,
+        openConnectModal: typeof openConnectModal,
+        walletMode
+      });
       setHasStartedLinking(true);
       setProviderType(null);
       if (isConnected) {
         disconnect();
         setTimeout(() => {
           setPage(null);
-          openConnectModal();
+          if (openConnectModal) {
+            openConnectModal();
+          } else {
+            console.error("[WalletConnectHandler] openConnectModal is undefined!");
+            setIsWalletLinking(false);
+            setHasStartedLinking(false);
+          }
         }, 500);
       } else {
         setPage(null);
-        openConnectModal();
+        if (openConnectModal) {
+          openConnectModal();
+        } else {
+          console.error("[WalletConnectHandler] openConnectModal is undefined!");
+          setIsWalletLinking(false);
+          setHasStartedLinking(false);
+        }
       }
     }
     if (!isWalletLinking && hasStartedLinking) {
       setHasStartedLinking(false);
-      if (isConnected) disconnect();
+      const shouldKeepConnected = walletMode === "direct" || walletMode === "both";
+      if (isConnected && !shouldKeepConnected) disconnect();
     }
-  }, [isWalletLinking, hasStartedLinking, isConnected, openConnectModal, disconnect, setPage, setProviderType]);
+  }, [isWalletLinking, hasStartedLinking, isConnected, openConnectModal, disconnect, setPage, setProviderType, walletMode]);
   useEffect36(() => {
     if (hasStartedLinking && !connectModalOpen && !isConnected && isWalletLinking) {
       console.log("[WalletConnectHandler] Modal closed without connecting");
@@ -16268,6 +16342,16 @@ function WalletConnectHandler() {
       setHasStartedLinking(false);
     }
   }, [connectModalOpen, hasStartedLinking, isConnected, isWalletLinking]);
+  useEffect36(() => {
+    if (isWalletLinking) {
+      const timeout = setTimeout(() => {
+        console.warn("[WalletConnectHandler] Wallet linking timed out, resetting state");
+        setIsWalletLinking(false);
+        setHasStartedLinking(false);
+      }, 12e4);
+      return () => clearTimeout(timeout);
+    }
+  }, [isWalletLinking, setIsWalletLinking]);
   const { mutate: handleWalletSign, isPending: isWalletSigning } = useMutation16({
     mutationFn: async (payload) => {
       const { chainId, signingWalletAddress } = payload;
@@ -16285,7 +16369,8 @@ function WalletConnectHandler() {
         return;
       }
       setLinkIsLoading(true);
-      const message = createSignatureMessage(signingWalletAddress);
+      const projectName = projectId ? await fetchProjectName(projectId) : "EmbarkAI";
+      const message = createSignatureMessage(signingWalletAddress, projectName);
       const signature = await signMessageAsync({ message, account: signingWalletAddress });
       if (!signature) {
         throw new Error("Failed to get signature");
@@ -16303,7 +16388,16 @@ function WalletConnectHandler() {
       });
     },
     onSuccess: () => {
-      disconnect();
+      const shouldKeepConnected = walletMode === "direct" || walletMode === "both";
+      if (shouldKeepConnected && walletAddress && chain?.id && connector) {
+        setExternalWallet({
+          address: walletAddress,
+          chainId: chain.id,
+          connectorName: connector.name || "Unknown Wallet"
+        });
+      } else {
+        disconnect();
+      }
       setHasStartedLinking(false);
       onLinkingComplete(true);
       setLinkIsLoading(false);
@@ -16343,6 +16437,17 @@ function WalletConnectHandler() {
       handleWalletSign({ chainId: chain.id, signingWalletAddress: walletAddress });
     }
   }, [chain, isConnected, walletAddress, isWalletLinking, hasStartedLinking]);
+  useEffect36(() => {
+    if (isConnected && !chain?.id && isWalletLinking && hasStartedLinking && !connectModalOpen && !isWalletSigning) {
+      const timeout = setTimeout(() => {
+        console.warn("[WalletConnectHandler] Wallet connected but chain info missing, resetting");
+        onLinkingComplete(false);
+        setHasStartedLinking(false);
+        disconnect();
+      }, 5e3);
+      return () => clearTimeout(timeout);
+    }
+  }, [isConnected, chain?.id, isWalletLinking, hasStartedLinking, connectModalOpen, isWalletSigning, onLinkingComplete, disconnect]);
   return null;
 }
 var init_WalletConnectHandler = __esm({
@@ -16353,10 +16458,67 @@ var init_WalletConnectHandler = __esm({
     init_wallet();
     init_AuthMenu2();
     init_useLayoutDataStore();
+    init_useExternalWalletStore();
     init_ManageWalletMenu();
   }
 });
 
+// src/internal/components/DirectWalletHandler.tsx
+import { useEffect as useEffect37 } from "react";
+import { useAccount as useAccount2 } from "wagmi";
+function DirectWalletHandler() {
+  const walletMode = useProviderConfig().config.current?.wallet?.mode || "linked";
+  const { address, isConnected, chain, connector } = useAccount2();
+  const isExternalConnected = useExternalWalletStore((st) => st.isExternalConnected);
+  const externalAddress = useExternalWalletStore((st) => st.externalAddress);
+  const setExternalWallet = useExternalWalletStore((st) => st.setExternalWallet);
+  const clearExternalWallet = useExternalWalletStore((st) => st.clearExternalWallet);
+  const setExternalChainId = useExternalWalletStore((st) => st.setExternalChainId);
+  const setConfigMode = useExternalWalletStore((st) => st.setConfigMode);
+  const setActiveMode = useExternalWalletStore((st) => st.setActiveMode);
+  useEffect37(() => {
+    setConfigMode(walletMode);
+    if (walletMode !== "both") {
+      setActiveMode(walletMode);
+    }
+  }, [walletMode, setConfigMode, setActiveMode]);
+  useEffect37(() => {
+    if (isConnected && address && !isExternalConnected && connector) {
+      setExternalWallet({
+        address,
+        chainId: chain?.id || 1,
+        connectorName: connector.name || "Unknown Wallet"
+      });
+    }
+  }, [isConnected, address, isExternalConnected, connector, chain?.id, setExternalWallet]);
+  useEffect37(() => {
+    if (isExternalConnected && !isConnected) {
+      clearExternalWallet();
+    }
+  }, [isConnected, isExternalConnected, clearExternalWallet]);
+  useEffect37(() => {
+    if (isExternalConnected && isConnected && chain?.id) {
+      setExternalChainId(chain.id);
+    }
+  }, [chain?.id, isConnected, isExternalConnected, setExternalChainId]);
+  useEffect37(() => {
+    if (isExternalConnected && isConnected && address && address !== externalAddress && connector) {
+      setExternalWallet({
+        address,
+        chainId: chain?.id || 1,
+        connectorName: connector.name || "Unknown Wallet"
+      });
+    }
+  }, [address, isConnected, isExternalConnected, externalAddress, chain?.id, connector, setExternalWallet]);
+  return null;
+}
+var init_DirectWalletHandler = __esm({
+  "src/internal/components/DirectWalletHandler.tsx"() {
+    init_ProviderContext();
+    init_useExternalWalletStore();
+  }
+});
+
 // src/context/SessionContext.tsx
 import {
   createBundlerClientForChain,
@@ -16366,7 +16528,7 @@ import {
   getViemChain as getViemChain2
 } from "@embarkai/core/read";
 import { Fragment as Fragment39 } from "react";
-import { create as create7 } from "zustand";
+import { create as create8 } from "zustand";
 import { persist } from "zustand/middleware";
 import { jsx as jsx93, jsxs as jsxs83 } from "react/jsx-runtime";
 function getChainParams(chainCfg) {
@@ -16389,6 +16551,7 @@ function SessionProvider({ children }) {
   return /* @__PURE__ */ jsxs83(Fragment39, { children: [
     children,
     config.current?.wallet?.enabled && /* @__PURE__ */ jsx93(WalletConnectHandler, {}),
+    config.current?.wallet?.enabled && (config.current?.wallet?.mode === "direct" || config.current?.wallet?.mode === "both") && /* @__PURE__ */ jsx93(DirectWalletHandler, {}),
     /* @__PURE__ */ jsx93(BalanceFeedProvider, {}),
     /* @__PURE__ */ jsx93(ChainSync, {}),
     /* @__PURE__ */ jsx93(
@@ -16408,8 +16571,9 @@ var init_SessionContext = __esm({
     init_Dialog2();
     init_TssManager();
     init_WalletConnectHandler();
+    init_DirectWalletHandler();
     init_ProviderContext();
-    useSession = create7()(
+    useSession = create8()(
       persist(
         (set) => ({
           isLoading: false,
@@ -17463,6 +17627,7 @@ __export(auth_exports, {
   deriveDemoPrivateKey: () => deriveDemoPrivateKey,
   ensureKeyshare: () => ensureKeyshare,
   ensureValidToken: () => ensureValidToken,
+  fetchProjectName: () => fetchProjectName,
   formatDate: () => formatDate,
   getKeyshareInfo: () => getKeyshareInfo,
   getLinkedProviders: () => getLinkedProviders,
@@ -18745,27 +18910,45 @@ var init_iframe_manager = __esm({
 // src/config/rainbowkit.ts
 import { lumiaMainnetChain as lumiaMainnetChain2, lumiaTestnetChain as lumiaTestnetChain2 } from "@embarkai/core/read";
 import { getDefaultConfig } from "@rainbow-me/rainbowkit";
+import {
+  coinbaseWallet,
+  metaMaskWallet,
+  rainbowWallet,
+  walletConnectWallet
+} from "@rainbow-me/rainbowkit/wallets";
 import { arbitrum, avalanche, base, bsc, mainnet, optimism, polygon, zora } from "wagmi/chains";
-var getProjectId, createRainbowConfig, rainbowConfig, rainbowTheme;
+var getProjectId, WALLET_MAP, createRainbowConfig, rainbowConfig, rainbowTheme;
 var init_rainbowkit = __esm({
   "src/config/rainbowkit.ts"() {
     getProjectId = (configProjectId) => {
-      if (configProjectId) {
-        return configProjectId;
-      }
+      if (configProjectId) return configProjectId;
       if (typeof window !== "undefined") {
         return window.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID || window.VITE_WALLET_CONNECT_PROJECT_ID || window.__WALLET_CONNECT_PROJECT_ID__ || "YOUR_PROJECT_ID";
       }
       return "YOUR_PROJECT_ID";
     };
-    createRainbowConfig = (projectId) => {
-      return getDefaultConfig({
+    WALLET_MAP = {
+      walletconnect: walletConnectWallet,
+      metamask: metaMaskWallet,
+      coinbase: coinbaseWallet,
+      rainbow: rainbowWallet
+    };
+    createRainbowConfig = (options) => {
+      const opts = typeof options === "string" ? { projectId: options } : options || {};
+      const config = {
         appName: "Mbark Wallet",
-        projectId: getProjectId(projectId),
+        projectId: getProjectId(opts.projectId),
         chains: [lumiaMainnetChain2, lumiaTestnetChain2, mainnet, polygon, bsc, arbitrum, optimism, avalanche, base, zora],
         ssr: false
-        // Set to true if using SSR
-      });
+      };
+      if (opts.allowedWallets && opts.allowedWallets.length > 0) {
+        const wallets = opts.allowedWallets.map((id) => WALLET_MAP[id.toLowerCase()]).filter(Boolean);
+        if (!opts.allowedWallets.some((id) => id.toLowerCase() === "walletconnect")) {
+          wallets.push(walletConnectWallet);
+        }
+        config.wallets = [{ groupName: "Supported", wallets }];
+      }
+      return getDefaultConfig(config);
     };
     rainbowConfig = createRainbowConfig();
     rainbowTheme = {
@@ -18968,7 +19151,13 @@ import { Fragment as Fragment40, jsx as jsx94 } from "react/jsx-runtime";
 function RainbowKitProvider({ children }) {
   const config = useProviderConfig().config;
   const colorMode = useLayoutStore((st) => st.colorMode);
-  const rainbowConfig2 = useMemo9(() => createRainbowConfig(config.current?.wallet?.walletConnectProjectId), []);
+  const rainbowConfig2 = useMemo9(
+    () => createRainbowConfig({
+      projectId: config.current?.wallet?.walletConnectProjectId,
+      allowedWallets: config.current?.wallet?.allowedWallets
+    }),
+    []
+  );
   const customTheme = useMemo9(() => {
     if (!config.current?.wallet?.enabled) return {};
     return colorMode === "dark" ? {
@@ -19064,7 +19253,7 @@ import {
   createContext,
   useCallback as useCallback24,
   useContext,
-  useEffect as useEffect37,
+  useEffect as useEffect38,
   useMemo as useMemo10,
   useRef as useRef15
 } from "react";
@@ -19072,11 +19261,11 @@ import { jsx as jsx96 } from "react/jsx-runtime";
 function Provider(props) {
   const { children, projectId, initialConfig = {}, callbacks } = props;
   const callbacksRef = useRef15(callbacks);
-  useEffect37(() => {
+  useEffect38(() => {
     callbacksRef.current = callbacks;
   }, [callbacks]);
-  useEffect37(() => notifyNoProjetctId(projectId), [projectId]);
-  const config = useRef15({ projectId, ...DEFAULT_PROVIDER_CONFIG });
+  useEffect38(() => notifyNoProjetctId(projectId), [projectId]);
+  const config = useRef15(merge3({}, DEFAULT_PROVIDER_CONFIG, { projectId }, initialConfig));
   const updateConfig = useCallback24((updates) => {
     const prev = config.current;
     const next = { ...prev };
@@ -19110,7 +19299,12 @@ function Provider(props) {
     if (updates.translations) next.translations = { ...next.translations, ...updates.translations };
     config.current = next;
   }, []);
-  useEffect37(() => {
+  const updateCallbacks = useCallback24((updates) => {
+    const prev = callbacksRef.current;
+    const next = updates ? { ...prev, ...updates } : void 0;
+    callbacksRef.current = next;
+  }, []);
+  useEffect38(() => {
     if (typeof window === "undefined" || !projectId) return;
     const mergedConfig = merge3(DEFAULT_PROVIDER_CONFIG, initialConfig);
     updateConfig(mergedConfig);
@@ -19128,7 +19322,7 @@ function Provider(props) {
       useSession.getState().setActiveChainId(mergedConfig.network.chainId);
     }
   }, [projectId, initialConfig]);
-  useEffect37(() => {
+  useEffect38(() => {
     if (typeof window === "undefined" || !projectId) return;
     try {
       initSdkErrorTracking();
@@ -19157,7 +19351,10 @@ function Provider(props) {
       console.error("[PROVIDER] Error setting up iframe manager:", error);
     }
   }, [projectId]);
-  const contextValue = useMemo10(() => ({ config, updateConfig, callbacks }), [config, updateConfig, callbacks]);
+  const contextValue = useMemo10(
+    () => ({ config, updateConfig, callbacks, updateCallbacks }),
+    [config, updateConfig, callbacks, updateCallbacks]
+  );
   if (!!initialConfig?.wallet?.enabled)
     return /* @__PURE__ */ jsx96(WagmiProvider2, { children: /* @__PURE__ */ jsx96(UIContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx96(RainbowKitProvider, { children: /* @__PURE__ */ jsx96(SessionProvider, { children }) }) }) });
   return /* @__PURE__ */ jsx96(WagmiProvider2, { children: /* @__PURE__ */ jsx96(UIContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx96(SessionProvider, { children }) }) });
@@ -19183,7 +19380,7 @@ var init_ProviderContext = __esm({
 // src/components/ConnectWalletButton.tsx
 import { useQuery as useQuery22 } from "@tanstack/react-query";
 import { Cloud as Cloud4, Laptop as Laptop2, Loader as Loader33, Shield as Shield3 } from "lucide-react";
-import { useEffect as useEffect38, useMemo as useMemo11 } from "react";
+import { useEffect as useEffect39, useMemo as useMemo11 } from "react";
 import { Fragment as Fragment41, jsx as jsx97, jsxs as jsxs84 } from "react/jsx-runtime";
 function getFormattedStatus(label, status, showStatus) {
   const isStatus = showStatus && status && status !== "idle" && status !== "ready";
@@ -19203,7 +19400,7 @@ function ConnectWalletButton(props) {
   const colorMode = useLayoutStore((st) => st.colorMode);
   const { session, address, hasServerVault, isLoading, isIframeReady, status, setUsePaymaster } = useSession();
   const connectButtonLabel = getFormattedStatus(label || "Connect", status, isIframeReady);
-  useEffect38(() => setUsePaymaster(usePaymaster), [setUsePaymaster, usePaymaster]);
+  useEffect39(() => setUsePaymaster(usePaymaster), [setUsePaymaster, usePaymaster]);
   const { data: profile, isLoading: isProfileLoading } = useQuery22({
     retry: false,
     enabled: !!address,
@@ -19990,7 +20187,7 @@ var init_Hash = __esm({
 });
 
 // src/internal/components/TransactionsMenu/TransactionsList.tsx
-import { useEffect as useEffect40, useState as useState25 } from "react";
+import { useEffect as useEffect41, useState as useState25 } from "react";
 import { jsx as jsx103, jsxs as jsxs88 } from "react/jsx-runtime";
 var TransactionsList;
 var init_TransactionsList = __esm({
@@ -20000,7 +20197,7 @@ var init_TransactionsList = __esm({
       const [transactions, setTransactions] = useState25([]);
       const [loading, setLoading] = useState25(true);
       const [error, setError] = useState25(null);
-      useEffect40(() => {
+      useEffect41(() => {
         const fetchTransactions2 = async () => {
           try {
             setLoading(true);
@@ -20294,13 +20491,229 @@ var init_useUserOpStatus = __esm({
   }
 });
 
+// src/hooks/useWalletMode.ts
+import { useCallback as useCallback28 } from "react";
+function useWalletMode() {
+  const configMode = useExternalWalletStore((st) => st.configMode);
+  const activeMode = useExternalWalletStore((st) => st.activeMode);
+  const setActiveMode = useExternalWalletStore((st) => st.setActiveMode);
+  const switchMode = useCallback28(
+    (mode) => {
+      if (configMode !== "both") return;
+      setActiveMode(mode);
+    },
+    [configMode, setActiveMode]
+  );
+  return {
+    configMode,
+    activeMode,
+    switchMode,
+    isDirect: activeMode === "direct"
+  };
+}
+var init_useWalletMode = __esm({
+  "src/hooks/useWalletMode.ts"() {
+    init_useExternalWalletStore();
+  }
+});
+
+// src/hooks/useDirectWallet.ts
+import { useCallback as useCallback29 } from "react";
+import { useConnectModal as useConnectModal2 } from "@rainbow-me/rainbowkit";
+import { useDisconnect as useDisconnect2 } from "wagmi";
+function useDirectWallet() {
+  const address = useExternalWalletStore((st) => st.externalAddress);
+  const chainId = useExternalWalletStore((st) => st.externalChainId);
+  const isConnected = useExternalWalletStore((st) => st.isExternalConnected);
+  const connectorName = useExternalWalletStore((st) => st.connectorName);
+  const clearExternalWallet = useExternalWalletStore((st) => st.clearExternalWallet);
+  const { disconnect: wagmiDisconnect } = useDisconnect2();
+  const { openConnectModal } = useConnectModal2();
+  const setIsWalletLinking = useLayoutDataStore((st) => st.setIsWalletLinking);
+  const connect = useCallback29(() => {
+    setIsWalletLinking(true);
+  }, [setIsWalletLinking]);
+  const reconnect = useCallback29(() => {
+    if (openConnectModal) openConnectModal();
+  }, [openConnectModal]);
+  const disconnect = useCallback29(() => {
+    wagmiDisconnect();
+    clearExternalWallet();
+  }, [wagmiDisconnect, clearExternalWallet]);
+  return {
+    address,
+    chainId,
+    isConnected,
+    connectorName,
+    connect,
+    reconnect,
+    disconnect
+  };
+}
+var init_useDirectWallet = __esm({
+  "src/hooks/useDirectWallet.ts"() {
+    init_useExternalWalletStore();
+    init_useLayoutDataStore();
+  }
+});
+
+// src/hooks/useSendDirectTransaction.ts
+import { useCallback as useCallback30, useState as useState27 } from "react";
+import { isAddress as isAddress3, parseEther as parseEther4 } from "viem";
+import { useSendTransaction as useWagmiSendTransaction, useSwitchChain } from "wagmi";
+function useSendDirectTransaction() {
+  const isConnected = useExternalWalletStore((st) => st.isExternalConnected);
+  const externalChainId = useExternalWalletStore((st) => st.externalChainId);
+  const { sendTransactionAsync } = useWagmiSendTransaction();
+  const { switchChainAsync } = useSwitchChain();
+  const [isPending, setIsPending] = useState27(false);
+  const [error, setError] = useState27(null);
+  const [txHash, setTxHash] = useState27(null);
+  const sendTransaction = useCallback30(
+    async (params) => {
+      if (!isConnected) {
+        setError("No external wallet connected");
+        return null;
+      }
+      if (!isAddress3(params.to)) {
+        setError("Invalid recipient address");
+        return null;
+      }
+      setIsPending(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        if (params.chainId && params.chainId !== externalChainId) {
+          await switchChainAsync({ chainId: params.chainId });
+        }
+        const hash = await sendTransactionAsync({
+          to: params.to,
+          value: parseEther4(params.value),
+          data: params.data
+        });
+        setTxHash(hash);
+        return hash;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Transaction failed";
+        setError(message);
+        return null;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [isConnected, externalChainId, sendTransactionAsync, switchChainAsync]
+  );
+  const reset = useCallback30(() => {
+    setError(null);
+    setTxHash(null);
+    setIsPending(false);
+  }, []);
+  return { sendTransaction, isPending, error, txHash, reset };
+}
+var init_useSendDirectTransaction = __esm({
+  "src/hooks/useSendDirectTransaction.ts"() {
+    init_useExternalWalletStore();
+  }
+});
+
+// src/hooks/useTransferToLinkedWallet.ts
+import { useCallback as useCallback31, useMemo as useMemo12, useState as useState28 } from "react";
+import { encodeFunctionData as encodeFunctionData4, isAddress as isAddress4, parseEther as parseEther5, parseUnits as parseUnits3 } from "viem";
+function useTransferToLinkedWallet() {
+  const session = useSession((st) => st.session);
+  const { profiles } = useLinkedProfiles();
+  const [isPending, setIsPending] = useState28(false);
+  const [error, setError] = useState28(null);
+  const [userOpHash, setUserOpHash] = useState28(null);
+  const linkedWallets = useMemo12(
+    () => (profiles || []).filter((p) => p.provider === "wallet" && p.externalId).map((p) => p.externalId),
+    [profiles]
+  );
+  const transfer = useCallback31(
+    async (params) => {
+      if (!session) {
+        setError("No active session");
+        return null;
+      }
+      const toAddress = params.toAddress || linkedWallets[0];
+      if (!toAddress || !isAddress4(toAddress)) {
+        setError("No linked wallet address available");
+        return null;
+      }
+      setIsPending(true);
+      setError(null);
+      setUserOpHash(null);
+      try {
+        let to;
+        let value;
+        let data;
+        if (params.token === "native") {
+          to = toAddress;
+          value = parseEther5(params.amount).toString();
+          data = "0x";
+        } else {
+          const decimals = params.decimals ?? 18;
+          to = params.token;
+          value = "0";
+          data = encodeFunctionData4({
+            abi: ERC20_TRANSFER_ABI2,
+            functionName: "transfer",
+            args: [toAddress, parseUnits3(params.amount, decimals)]
+          });
+        }
+        const hash = await sendUserOperation2(session, {
+          to,
+          value,
+          data,
+          feeType: "standard",
+          chainId: params.chainId
+        });
+        setUserOpHash(hash);
+        return hash;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Transfer failed";
+        setError(message);
+        return null;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [session, linkedWallets]
+  );
+  const reset = useCallback31(() => {
+    setError(null);
+    setUserOpHash(null);
+    setIsPending(false);
+  }, []);
+  return { transfer, isPending, error, userOpHash, linkedWallets, reset };
+}
+var ERC20_TRANSFER_ABI2;
+var init_useTransferToLinkedWallet = __esm({
+  "src/hooks/useTransferToLinkedWallet.ts"() {
+    init_SessionContext();
+    init_account();
+    init_linkedProfiles();
+    ERC20_TRANSFER_ABI2 = [
+      {
+        type: "function",
+        name: "transfer",
+        inputs: [
+          { name: "to", type: "address" },
+          { name: "amount", type: "uint256" }
+        ],
+        outputs: [{ name: "", type: "bool" }]
+      }
+    ];
+  }
+});
+
 // src/hooks/useLogout.ts
 import { logout as coreLogout, jwtTokenManager as jwtTokenManager3 } from "@embarkai/core/auth";
-import { useCallback as useCallback28 } from "react";
+import { useCallback as useCallback32 } from "react";
 function useLogout() {
   const { setSession, setIsLoading, setAddress, setStatus, setError, address } = useSession();
   const { callbacks } = useProviderConfig();
-  const logout2 = useCallback28(async () => {
+  const logout2 = useCallback32(async () => {
     const prevAddress = address;
     let userId = null;
     setIsLoading(true);
@@ -20390,21 +20803,21 @@ var init_clients2 = __esm({
 
 // src/modules/transactions.ts
 import { getViemChain as getViemChain4 } from "@embarkai/core/read";
-import { parseEther as parseEther4 } from "viem";
-import { useAccount as useAccount2, usePublicClient, useWalletClient } from "wagmi";
+import { parseEther as parseEther6 } from "viem";
+import { useAccount as useAccount3, usePublicClient, useWalletClient } from "wagmi";
 function useTransactions() {
   const chainId = requireActiveChainId();
   const viemChain = getViemChain4(chainId);
   const publicClient = usePublicClient({ chainId });
   const { data: walletClient } = useWalletClient();
-  const { address } = useAccount2();
+  const { address } = useAccount3();
   const sendTransaction = async (params) => {
     if (!walletClient) {
       throw new Error("Wallet not connected");
     }
     const txParams = {
       to: params.to,
-      value: parseEther4(params.value),
+      value: parseEther6(params.value),
       data: params.data,
       chain: viemChain
     };
@@ -20721,6 +21134,10 @@ var init_index = __esm({
     init_useSendTransaction();
     init_useUserOpStatus();
     init_useErc3643Compliance();
+    init_useWalletMode();
+    init_useDirectWallet();
+    init_useSendDirectTransaction();
+    init_useTransferToLinkedWallet();
     init_useLogout();
     init_useNicknameResolve();
     init_account();
@@ -20786,6 +21203,7 @@ export {
   useAssets,
   useBalance,
   useColorMode,
+  useDirectWallet,
   useErc3643Compliance,
   useError,
   useHasServerVault,
@@ -20799,13 +21217,16 @@ export {
   useOpenPage,
   useProviderConfig,
   useRecoveryUserId,
+  useSendDirectTransaction,
   useSendTransaction,
   useSession,
   useSmartAccountTransactions,
   useTokenBalance,
   useTokenInfo,
   useTransactions,
+  useTransferToLinkedWallet,
   useUserOpStatus,
+  useWalletMode,
   verifyFingerprint,
   verifyFingerprintDetailed,
   wagmiConfig,