@hardkas/react 0.7.13-alpha → 0.8.1-alpha

package/dist/index.js

@@ -1,1552 +1,96 @@
 // src/provider.tsx
-import React, { createContext, useContext, useMemo } from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createPublicClient, http } from "viem";
-import { jsx, jsxs } from "react/jsx-runtime";
-var HardKasContext = createContext(void 0);
-function HardKasProvider({
-  config,
-  children,
-  queryClient: externalQueryClient
-}) {
-  const queryClient = useMemo(
-    () => externalQueryClient ?? new QueryClient(),
-    [externalQueryClient]
-  );
-  const [sseStatus, setSseStatus] = React.useState("disconnected");
-  const [projectionStatus, setProjectionStatus] = React.useState("synced");
-  const [generationId, setGenerationId] = React.useState(null);
-  const [lastSyncedAt, setLastSyncedAt] = React.useState(null);
-  const [lastEvent, setLastEvent] = React.useState(null);
-  const listeners = React.useRef(/* @__PURE__ */ new Set());
-  const eventSource = React.useRef(null);
-  const reconnectTimer = React.useRef(null);
-  const backoffMs = React.useRef(500);
-  const [providers, setProviders] = React.useState([]);
-  const [activeProvider, setActiveProvider] = React.useState(null);
-  const [walletAddress, setWalletAddress] = React.useState(null);
-  const [walletChainId, setWalletChainId] = React.useState(null);
-  const devToken = React.useMemo(() => {
-    if (typeof window !== "undefined") {
-      if (window.__HARDKAS_DEV_TOKEN__) {
-        return window.__HARDKAS_DEV_TOKEN__;
-      }
-      const params = new URLSearchParams(window.location.search);
-      return params.get("token") || "";
-    }
-    return "";
-  }, []);
-  const [tokenMissing, setTokenMissing] = React.useState(false);
-  React.useEffect(() => {
-    if (typeof window !== "undefined") {
-      const isTest = typeof globalThis.vi !== "undefined" || window.__MOCK_SSE__ || process.env.NODE_ENV === "test";
-      const isDashboard = window.location.pathname.startsWith("/") || window.location.port === "7420" || window.location.port === "5173";
-      if (isDashboard && !isTest && !devToken) {
-        setTokenMissing(true);
-      }
-    }
-  }, [devToken]);
-  const subscribe = React.useCallback((callback) => {
-    listeners.current.add(callback);
-    return () => listeners.current.delete(callback);
-  }, []);
-  const apiFetch = React.useCallback(
-    async (input, init) => {
-      const headers = new Headers(init?.headers || {});
-      if (devToken) {
-        headers.set("Authorization", `Bearer ${devToken}`);
-      }
-      const method = init?.method?.toUpperCase() || "GET";
-      if (["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-        headers.set("X-Hardkas-Request", "true");
-      }
-      const mergedInit = {
-        ...init,
-        headers
-      };
-      const response = await fetch(input, mergedInit);
-      const genHeader = response.headers?.get?.("X-Hardkas-Generation");
-      if (genHeader) {
-        setGenerationId((prev) => {
-          if (prev !== genHeader) {
-            setTimeout(() => {
-              if (queryClient) queryClient.invalidateQueries();
-            }, 0);
-            return genHeader;
-          }
-          return prev;
-        });
-      }
-      return response;
-    },
-    [queryClient, devToken]
-  );
-  const connect = React.useCallback(() => {
-    if (typeof window === "undefined") return;
-    if (!config.devServerUrl) {
-      setSseStatus("disconnected");
-      return;
-    }
-    if (typeof EventSource === "undefined") {
-      setSseStatus("failed");
-      return;
-    }
-    if (eventSource.current) {
-      eventSource.current.close();
-    }
-    setSseStatus("connecting");
-    const baseUrl = config.devServerUrl;
-    let url = baseUrl.endsWith("/") ? `${baseUrl}api/stream` : `${baseUrl}/api/stream`;
-    if (devToken) {
-      url += (url.includes("?") ? "&" : "?") + `token=${encodeURIComponent(devToken)}`;
-    }
-    const es = new EventSource(url);
-    eventSource.current = es;
-    if (typeof window !== "undefined") {
-      window.__MOCK_SSE_CLOSE__ = () => {
-        es.close();
-        if (es.onerror) {
-          es.onerror.call(es, new Event("error"));
-        }
-      };
-    }
-    es.onopen = () => {
-      setSseStatus("connected");
-      backoffMs.current = 500;
-    };
-    es.onerror = () => {
-      es.close();
-      eventSource.current = null;
-      setSseStatus("reconnecting");
-      const nextBackoff = Math.min(backoffMs.current * 2, 1e4);
-      backoffMs.current = nextBackoff;
-      reconnectTimer.current = setTimeout(() => {
-        connect();
-      }, nextBackoff);
-    };
-    es.onmessage = (e) => {
-      const event = {
-        type: "message",
-        payload: e.data,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setLastEvent(event);
-      listeners.current.forEach((l) => l(event));
-    };
-    const namedEvents = [
-      "session-changed",
-      "session-created",
-      "session-deleted",
-      "health-changed",
-      "sandbox-session-created",
-      "sandbox-session-paired",
-      "sandbox-session-expired",
-      "sandbox-session-disconnected",
-      "projection-stale",
-      "projection-synced",
-      "query-synced",
-      "ping",
-      "heartbeat"
-    ];
-    namedEvents.forEach((type) => {
-      es.addEventListener(type, (e) => {
-        const event = {
-          type,
-          payload: e.data ? JSON.parse(e.data) : void 0,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        setLastEvent(event);
-        listeners.current.forEach((l) => l(event));
-        if (type === "projection-stale") {
-          setProjectionStatus("stale");
-        }
-        if (type === "projection-synced" || type === "query-synced") {
-          setProjectionStatus("synced");
-          setLastSyncedAt((/* @__PURE__ */ new Date()).toISOString());
-          if (event.payload?.generationId) {
-            setGenerationId(event.payload.generationId);
-          }
-          queryClient.invalidateQueries();
-        }
-      });
-    });
-  }, [config.devServerUrl, queryClient, devToken]);
-  React.useEffect(() => {
-    connect();
-    return () => {
-      if (eventSource.current) {
-        eventSource.current.close();
-        eventSource.current = null;
-      }
-      if (reconnectTimer.current) {
-        clearTimeout(reconnectTimer.current);
-      }
-    };
-  }, [connect]);
-  React.useEffect(() => {
-    if (typeof window === "undefined") return;
-    const handleAnnounce = (event) => {
-      const detail = event.detail;
-      if (!detail || !detail.info || !detail.provider) return;
-      setProviders((prev) => {
-        if (prev.some((p) => p.info.rdns === detail.info.rdns)) return prev;
-        return [...prev, detail];
-      });
-    };
-    window.addEventListener("eip6963:announceProvider", handleAnnounce);
-    window.dispatchEvent(new Event("eip6963:requestProvider"));
-    return () => {
-      window.removeEventListener("eip6963:announceProvider", handleAnnounce);
-    };
-  }, []);
-  const connectWallet = React.useCallback(async (detail) => {
-    try {
-      const accounts = await detail.provider.request({ method: "eth_requestAccounts" });
-      const chainIdHex = await detail.provider.request({ method: "eth_chainId" });
-      const chainId = typeof chainIdHex === "string" ? parseInt(chainIdHex, 16) : Number(chainIdHex);
-      setActiveProvider(detail);
-      if (accounts && accounts[0]) {
-        setWalletAddress(accounts[0]);
-      }
-      setWalletChainId(chainId);
-      if (typeof window !== "undefined") {
-        window.localStorage.setItem("hardkas:active-wallet", detail.info.rdns);
-      }
-    } catch (err) {
-      console.error("Failed to connect wallet:", err);
-      throw err;
-    }
-  }, []);
-  const disconnectWallet = React.useCallback(() => {
-    setActiveProvider(null);
-    setWalletAddress(null);
-    setWalletChainId(null);
-    if (typeof window !== "undefined") {
-      window.localStorage.removeItem("hardkas:active-wallet");
-    }
-  }, []);
-  const switchChain = React.useCallback(
-    async (targetChainId) => {
-      if (!activeProvider) {
-        throw new Error("No active wallet connected");
-      }
-      const hexChainId = `0x${targetChainId.toString(16)}`;
-      try {
-        await activeProvider.provider.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId: hexChainId }]
-        });
-        setWalletChainId(targetChainId);
-      } catch (err) {
-        if (err.code === 4902) {
-          if (targetChainId === 19416) {
-            await activeProvider.provider.request({
-              method: "wallet_addEthereumChain",
-              params: [
-                {
-                  chainId: hexChainId,
-                  chainName: "Igra Local",
-                  nativeCurrency: { name: "Igra Kaspa", symbol: "iKAS", decimals: 18 },
-                  rpcUrls: [config.igraRpcUrl || "http://127.0.0.1:8545"]
-                }
-              ]
-            });
-            setWalletChainId(targetChainId);
-          } else {
-            throw err;
-          }
-        } else {
-          throw err;
-        }
-      }
-    },
-    [activeProvider, config.igraRpcUrl]
-  );
-  React.useEffect(() => {
-    if (typeof window === "undefined" || providers.length === 0 || activeProvider) return;
-    const savedRdns = window.localStorage.getItem("hardkas:active-wallet");
-    if (savedRdns) {
-      const match = providers.find((p) => p.info.rdns === savedRdns);
-      if (match) {
-        connectWallet(match).catch(() => {
-        });
-      }
-    }
-  }, [providers, activeProvider, connectWallet]);
-  React.useEffect(() => {
-    if (!activeProvider) {
-      setWalletAddress(null);
-      setWalletChainId(null);
-      return;
-    }
-    const provider = activeProvider.provider;
-    const handleAccountsChanged = (accounts) => {
-      if (accounts && accounts[0]) {
-        setWalletAddress(accounts[0]);
-      } else {
-        setActiveProvider(null);
-        setWalletAddress(null);
-        setWalletChainId(null);
-        if (typeof window !== "undefined") {
-          window.localStorage.removeItem("hardkas:active-wallet");
-        }
-      }
-    };
-    const handleChainChanged = (chainIdHex) => {
-      const chainId = typeof chainIdHex === "string" ? parseInt(chainIdHex, 16) : Number(chainIdHex);
-      setWalletChainId(chainId);
-    };
-    const handleDisconnect = () => {
-      setActiveProvider(null);
-      setWalletAddress(null);
-      setWalletChainId(null);
-      if (typeof window !== "undefined") {
-        window.localStorage.removeItem("hardkas:active-wallet");
-      }
-    };
-    if (provider.on) {
-      provider.on("accountsChanged", handleAccountsChanged);
-      provider.on("chainChanged", handleChainChanged);
-      provider.on("disconnect", handleDisconnect);
-    }
-    return () => {
-      if (provider.removeListener) {
-        provider.removeListener("accountsChanged", handleAccountsChanged);
-        provider.removeListener("chainChanged", handleChainChanged);
-        provider.removeListener("disconnect", handleDisconnect);
-      }
-    };
-  }, [activeProvider]);
-  const igraClient = useMemo(() => {
-    return createPublicClient({
-      chain: {
-        id: 19416,
-        // Igra Local Default
-        name: "Igra Local",
-        nativeCurrency: { name: "Igra Kaspa", symbol: "iKAS", decimals: 18 },
-        rpcUrls: {
-          default: { http: [config.igraRpcUrl || "http://127.0.0.1:8545"] }
-        }
-      },
-      transport: http(config.igraRpcUrl || "http://127.0.0.1:8545", { retryCount: 0 })
-    });
-  }, [config.igraRpcUrl]);
-  const value = useMemo(
-    () => ({
-      config: {
-        ...config,
-        localOnly: config.localOnly ?? true
-      },
-      igraClient,
-      queryClient,
-      sseStatus,
-      projectionStatus,
-      generationId,
-      lastSyncedAt,
-      apiFetch,
-      lastEvent,
-      subscribe,
-      providers,
-      activeProvider,
-      walletAddress,
-      walletChainId,
-      connectWallet,
-      disconnectWallet,
-      switchChain
-    }),
-    [
-      config,
-      igraClient,
-      queryClient,
-      sseStatus,
-      projectionStatus,
-      generationId,
-      lastSyncedAt,
-      apiFetch,
-      lastEvent,
-      subscribe,
-      providers,
-      activeProvider,
-      walletAddress,
-      walletChainId,
-      connectWallet,
-      disconnectWallet,
-      switchChain
-    ]
-  );
-  return /* @__PURE__ */ jsx(HardKasContext.Provider, { value, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: tokenMissing ? /* @__PURE__ */ jsx(
-    "div",
-    {
-      style: {
-        display: "flex",
-        flexDirection: "column",
-        alignItems: "center",
-        justifyContent: "center",
-        height: "100vh",
-        width: "100vw",
-        backgroundColor: "#1a1a1a",
-        color: "#f87171",
-        fontFamily: "sans-serif",
-        textAlign: "center",
-        padding: "20px"
-      },
-      children: /* @__PURE__ */ jsxs(
-        "div",
-        {
-          style: {
-            backgroundColor: "#2d2d2d",
-            border: "2px solid #ef4444",
-            borderRadius: "8px",
-            padding: "30px",
-            maxWidth: "450px",
-            boxShadow: "0 10px 15px -3px rgba(0, 0, 0, 0.5)"
-          },
-          children: [
-            /* @__PURE__ */ jsx("h2", { style: { color: "#ef4444", marginTop: 0 }, children: "Dashboard authentication token missing." }),
-            /* @__PURE__ */ jsx("p", { style: { color: "#d1d5db", lineHeight: "1.5" }, children: "The dev-server is secured against local workstation CSRF and DNS rebinding attacks." }),
-            /* @__PURE__ */ jsx("p", { style: { color: "#9ca3af", fontWeight: "bold" }, children: "Restart hardkas dashboard." })
-          ]
-        }
-      )
-    }
-  ) : children }) });
-}
-function useHardKas() {
-  const context = useContext(HardKasContext);
+import { createContext, useContext, useMemo } from "react";
+import { createClient } from "@hardkas/client";
+import { jsx } from "react/jsx-runtime";
+var HardKASContext = createContext(null);
+var HardKASProvider = ({ children, baseUrl, timeout }) => {
+  const client = useMemo(() => {
+    const config = {};
+    if (baseUrl !== void 0) config.baseUrl = baseUrl;
+    if (timeout !== void 0) config.timeout = timeout;
+    return createClient(config);
+  }, [baseUrl, timeout]);
+  return /* @__PURE__ */ jsx(HardKASContext.Provider, { value: client, children });
+};
+var useHardKAS = () => {
+  const context = useContext(HardKASContext);
   if (!context) {
-    throw new Error("useHardKas must be used within a HardKasProvider");
+    throw new Error("useHardKAS must be used within a HardKASProvider");
   }
   return context;
-}
-
-// src/hooks/session.ts
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useEffect } from "react";
-function useHardKasSession(name) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient();
-  const sessionToResolve = name || config.sessionName;
-  useEffect(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "session"] });
-    return subscribe((event) => {
-      if (["session-changed", "session-created", "session-deleted"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery({
-    queryKey: ["hardkas", "session", sessionToResolve || "active"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/session` : `${baseUrl}/api/session` : "/api/session";
-        const response = await apiFetch(url);
-        const json = await response.json();
-        const active = json.active;
-        if (!active) return null;
-        return {
-          name: active.name,
-          l1: { wallet: active.l1?.wallet, address: active.l1?.address },
-          l2: { account: active.l2?.account, address: active.l2?.address },
-          bridge: { mode: active.bridge?.mode },
-          health: active.health || { isHealthy: true, warnings: [] },
-          diagnostics: json.diagnostics || []
-        };
-      } catch (e) {
-        console.error("Failed to fetch session from dev server:", e);
-        return null;
-      }
-    },
-    staleTime: 3e4
-    // Rely on SSE for updates
-  });
-}
-
-// src/hooks/health.ts
-import { useQuery as useQuery2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
-import { useEffect as useEffect2 } from "react";
-function useHardKasHealth() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient2();
-  useEffect2(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "health"] });
-    return subscribe((event) => {
-      if (["health-changed", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery2({
-    queryKey: ["hardkas", "health"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/health` : `${baseUrl}/api/health` : "/api/health";
-        const res = await apiFetch(url);
-        if (!res || !res.ok) {
-          throw new Error("Failed to fetch health from dev server");
-        }
-        return await res.json();
-      } catch (e) {
-        console.error("Failed to fetch health from dev server:", e);
-        throw e;
-      }
-    },
-    refetchInterval: 3e4,
-    // Background poll as fallback
-    retry: 2
-  });
-}
-
-// src/hooks/kaspa.ts
-import { useQuery as useQuery3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
-import { useEffect as useEffect3 } from "react";
-function useKaspaWallet() {
-  const { data: session } = useHardKasSession();
-  return {
-    name: session?.l1.wallet,
-    address: session?.l1.address,
-    isLoading: !session
-  };
-}
-function useKaspaBalance(options = {}) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient3();
-  const { address, name } = useKaspaWallet();
-  const { data: health } = useHardKasHealth();
-  useEffect3(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["kaspa", "balance"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  const l1Status = health?.kaspa?.status || health?.l1?.status;
-  const isL1Online = l1Status === "healthy" || l1Status === "simulated-mode" || l1Status === "ok" || l1Status === "running" || l1Status === "online" || !!address && address.startsWith("kaspa:sim_");
-  return useQuery3({
-    queryKey: ["kaspa", "balance", address, config.kaspaRpcUrl, name],
-    queryFn: async () => {
-      if (!address) return 0n;
-      if (address.startsWith("kaspa:sim_") || l1Status === "simulated-mode") {
-        try {
-          const baseUrl = config.devServerUrl || "";
-          const fetchUrl = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
-          const res = await apiFetch(fetchUrl);
-          if (res.ok) {
-            const data = await res.json();
-            const match = (data.accounts || []).find((a) => a.address === address);
-            if (match) {
-              return BigInt(match.balanceSompi || match.balance || "0");
-            }
-          }
-        } catch (e) {
-          console.warn(
-            "Failed to fetch derived simulated balance, falling back to 0:",
-            e
-          );
-        }
-        return 0n;
-      }
-      let url = config.kaspaRpcUrl || "http://127.0.0.1:16110";
-      if (url.includes("127.0.0.1:16110") || url.includes("localhost:16110")) {
-        url = "ws://127.0.0.1:18210";
-      } else if (url.includes("127.0.0.1:18210") || url.includes("localhost:18210")) {
-        url = "ws://127.0.0.1:18210";
-      }
-      if (url.startsWith("ws://") || url.startsWith("wss://")) {
-        try {
-          return await new Promise((resolve, reject) => {
-            const ws = new WebSocket(url);
-            const timer = setTimeout(() => {
-              ws.close();
-              reject(new Error("WebSocket timeout"));
-            }, 3e3);
-            ws.onopen = () => {
-              ws.send(
-                JSON.stringify({
-                  id: 1,
-                  method: "getBalanceByAddressRequest",
-                  params: { address }
-                })
-              );
-            };
-            ws.onmessage = (event) => {
-              clearTimeout(timer);
-              try {
-                const response = JSON.parse(event.data);
-                ws.close();
-                if (response.error) {
-                  reject(new Error(response.error.message));
-                } else {
-                  const data = response.result !== void 0 ? response.result : response.params;
-                  resolve(BigInt(data?.balance || 0));
-                }
-              } catch (err) {
-                ws.close();
-                reject(err);
-              }
-            };
-            ws.onerror = (err) => {
-              clearTimeout(timer);
-              ws.close();
-              reject(err);
-            };
-          });
-        } catch (e) {
-          console.warn(
-            "Failed to fetch Kaspa balance via WebSocket, falling back to 0:",
-            e
-          );
-          return 0n;
-        }
-      }
-      try {
-        const response = await apiFetch(url, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "getBalanceByAddressRequest",
-            params: { address }
-          })
-        });
-        const json = await response.json();
-        return BigInt(json.result?.balance || 0);
-      } catch (e) {
-        return 0n;
-      }
-    },
-    enabled: !!address && isL1Online,
-    refetchInterval: options.refetchInterval ?? false
-  });
-}
-
-// src/hooks/igra.ts
-import { useQuery as useQuery4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
-import { useEffect as useEffect4 } from "react";
-function useIgraAccount() {
-  const { data: session } = useHardKasSession();
-  const { walletAddress, apiFetch } = useHardKas();
-  const address = walletAddress || session?.l2.address;
-  return {
-    name: walletAddress ? "Browser Wallet" : session?.l2.account,
-    address,
-    isWallet: !!walletAddress,
-    isLoading: !session && !walletAddress
-  };
-}
-function useIgraWallet() {
-  const {
-    providers,
-    activeProvider,
-    walletAddress,
-    walletChainId,
-    connectWallet,
-    disconnectWallet,
-    switchChain,
-    apiFetch
-  } = useHardKas();
-  return {
-    providers,
-    activeProvider,
-    walletAddress,
-    walletChainId,
-    connectWallet,
-    disconnectWallet,
-    switchChain,
-    isConnected: !!walletAddress
-  };
-}
-function useIgraBalance(options = {}) {
-  const { igraClient, config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient4();
-  const { address } = useIgraAccount();
-  useEffect4(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["igra", "balance"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  const { data: session } = useHardKasSession();
-  const { data: health } = useHardKasHealth();
-  const l2Status = health?.igra?.status || health?.l2?.status;
-  const isL2Online = l2Status === "healthy" || l2Status === "ok" || l2Status === "running" || l2Status === "online" || !!address && (address.startsWith("0xsim_") || address.startsWith("kaspa:sim_") || !address.startsWith("0x"));
-  return useQuery4({
-    queryKey: ["igra", "balance", address, config.igraRpcUrl, session?.name],
-    queryFn: async () => {
-      if (!address) return 0n;
-      if (address.startsWith("0xsim_") || !address.startsWith("0x") || l2Status === "simulated-mode") {
-        try {
-          const baseUrl = config.devServerUrl || "";
-          const fetchUrl = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
-          const res = await apiFetch(fetchUrl);
-          if (res.ok) {
-            const data = await res.json();
-            const match = (data.accounts || []).find(
-              (a) => a.address.toLowerCase() === address.toLowerCase() || a.name.toLowerCase() === address.toLowerCase()
-            );
-            if (match) {
-              return BigInt(match.balanceSompi || match.balance || "0");
-            }
-          }
-        } catch (e) {
-          console.warn(
-            "Failed to fetch derived simulated L2 balance, falling back to 0:",
-            e
-          );
-        }
-        return 0n;
-      }
-      try {
-        return await igraClient.getBalance({ address });
-      } catch (e) {
-        return 0n;
-      }
-    },
-    enabled: !!address && isL2Online,
-    refetchInterval: options.refetchInterval ?? false
-  });
-}
-
-// src/hooks/events.ts
-import { useQuery as useQuery5 } from "@tanstack/react-query";
-import { useEffect as useEffect5 } from "react";
-import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
-function useEvents(kind, txId) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient5();
-  const queryKey = ["hardkas", "events", kind, txId];
-  useEffect5(() => {
-    return subscribe((event) => {
-      queryClient.invalidateQueries({ queryKey: ["hardkas", "events"] });
-    });
-  }, [queryClient, subscribe]);
-  return useQuery5({
-    queryKey,
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const queryParams = new URLSearchParams();
-        if (kind) queryParams.append("kind", kind);
-        if (txId) queryParams.append("txId", txId);
-        const queryStr = queryParams.toString() ? `?${queryParams.toString()}` : "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/events${queryStr}` : `${baseUrl}/api/events${queryStr}` : `/api/events${queryStr}`;
-        const response = await apiFetch(url);
-        if (!response.ok) return { events: [] };
-        const data = await response.json();
-        return {
-          events: data.events || [],
-          observabilityDrift: data.observabilityDrift,
-          reason: data.reason
-        };
-      } catch (e) {
-        console.error("Failed to fetch events from dev server:", e);
-        return { events: [] };
-      }
-    },
-    staleTime: 5e3
-  });
-}
-
-// src/hooks/metamask.ts
-import { useState, useEffect as useEffect6, useCallback } from "react";
-import { createWalletClient, custom } from "viem";
-var getMetaMaskProvider = () => {
-  if (typeof window === "undefined" || !window.ethereum) return null;
-  if (window.ethereum.providers) {
-    return window.ethereum.providers.find((p) => p.isMetaMask) || window.ethereum;
-  }
-  return window.ethereum;
 };
-function useMetaMaskLocal() {
-  const [state, setState] = useState({
-    installed: false,
-    connected: false,
-    supported: false,
-    localIgraDetected: false,
-    errors: []
-  });
-  const checkStatus = useCallback(async () => {
-    const provider = getMetaMaskProvider();
-    if (!provider) {
-      setState((s) => ({ ...s, installed: false }));
-      return;
-    }
-    try {
-      const chainIdHex = await provider.request({ method: "eth_chainId" });
-      const chainId = parseInt(chainIdHex, 16);
-      const accounts = await provider.request({
-        method: "eth_accounts"
-      });
-      setState({
-        installed: true,
-        connected: accounts.length > 0,
-        supported: true,
-        account: accounts[0],
-        chainId,
-        localIgraDetected: chainId === 19416,
-        errors: []
-      });
-    } catch (e) {
-      setState((s) => ({ ...s, errors: [e.message] }));
-    }
-  }, []);
-  const connect = useCallback(async () => {
-    const provider = getMetaMaskProvider();
-    if (!provider) return;
-    try {
-      await provider.request({ method: "eth_requestAccounts" });
-      await checkStatus();
-    } catch (e) {
-      setState((s) => ({ ...s, errors: [...s.errors, e.message] }));
-    }
-  }, [checkStatus]);
-  useEffect6(() => {
-    const provider = getMetaMaskProvider();
-    if (!provider) return;
-    checkStatus();
-    const handleChange = () => checkStatus();
-    provider.on("accountsChanged", handleChange);
-    provider.on("chainChanged", handleChange);
-    provider.on("disconnect", handleChange);
-    return () => {
-      if (provider.removeListener) {
-        provider.removeListener("accountsChanged", handleChange);
-        provider.removeListener("chainChanged", handleChange);
-        provider.removeListener("disconnect", handleChange);
-      }
-    };
-  }, [checkStatus]);
-  return { state, refresh: checkStatus, connect };
-}
-function useSwitchToLocalIgra() {
-  const switchChain = async () => {
-    const provider = getMetaMaskProvider();
-    if (!provider) return;
-    try {
-      await provider.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: "0x4bd8" }]
-        // 19416
-      });
-    } catch (e) {
-      if (e.code === 4902) {
-        await provider.request({
-          method: "wallet_addEthereumChain",
-          params: [
-            {
-              chainId: "0x4bd8",
-              chainName: "HardKas Igra Local",
-              rpcUrls: ["http://127.0.0.1:8545"],
-              nativeCurrency: { name: "iKAS", symbol: "iKAS", decimals: 18 }
-            }
-          ]
-        });
-      }
-    }
-  };
-  return { switchChain };
-}
-function useIgraInjectedAccount(sessionL2Address) {
-  const { state } = useMetaMaskLocal();
-  const matches = !!state.account && !!sessionL2Address && state.account.toLowerCase() === sessionL2Address.toLowerCase();
-  return {
-    injectedAddress: state.account,
-    sessionAddress: sessionL2Address,
-    matches
-  };
-}
-function useLocalIgraWalletClient() {
-  const { state } = useMetaMaskLocal();
-  const getClient = useCallback(() => {
-    const provider = getMetaMaskProvider();
-    if (!state.connected || !provider) return null;
-    return createWalletClient({
-      account: state.account,
-      transport: custom(provider)
-    });
-  }, [state.connected, state.account]);
-  return { getClient };
-}
 
-// src/hooks/kasware.ts
-import { useState as useState2, useEffect as useEffect7, useCallback as useCallback2 } from "react";
-function useKasWareLocal() {
-  const [state, setState] = useState2({
-    installed: false,
-    connected: false,
-    supported: false,
-    localNetworkDetected: false,
-    errors: []
-  });
-  const checkStatus = useCallback2(async () => {
-    if (typeof window === "undefined" || !window.kasware) {
-      setState((s) => ({ ...s, installed: false }));
-      return;
-    }
+// src/hooks/useQuery.ts
+import { useState, useEffect, useCallback } from "react";
+function useQuery(queryFn, deps = [], options = { enabled: true }) {
+  const client = useHardKAS();
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const refetch = useCallback(async () => {
+    setLoading(true);
+    setError(null);
     try {
-      const provider = window.kasware;
-      const accounts = await provider.getAccounts();
-      const network = await provider.getNetwork();
-      setState({
-        installed: true,
-        connected: accounts.length > 0,
-        supported: true,
-        address: accounts[0],
-        network,
-        // Common local/dev network strings for KasWare
-        localNetworkDetected: ["kasparegtest", "localnet", "simnet"].includes(network),
-        errors: []
-      });
-    } catch (e) {
-      setState((s) => ({ ...s, errors: [e.message] }));
-    }
-  }, []);
-  useEffect7(() => {
-    if (typeof window === "undefined" || !window.kasware) return;
-    const provider = window.kasware;
-    checkStatus();
-    const handleChange = () => checkStatus();
-    provider.on("accountsChanged", handleChange);
-    provider.on("networkChanged", handleChange);
-    provider.on("disconnect", handleChange);
-    return () => {
-      if (provider.removeListener) {
-        provider.removeListener("accountsChanged", handleChange);
-        provider.removeListener("networkChanged", handleChange);
-        provider.removeListener("disconnect", handleChange);
-      }
-    };
-  }, [checkStatus]);
-  return { state, refresh: checkStatus };
-}
-function useConnectKasWareLocal() {
-  const { refresh } = useKasWareLocal();
-  const connect = async () => {
-    if (typeof window === "undefined" || !window.kasware) return null;
-    try {
-      const accounts = await window.kasware.requestAccounts();
-      await refresh();
-      return accounts[0];
-    } catch (e) {
-      console.error("KasWare connection failed:", e);
-      return null;
-    }
-  };
-  return { connect };
-}
-function useKasWareSessionMatch(sessionL1Address) {
-  const { state } = useKasWareLocal();
-  let matches = false;
-  let reason;
-  if (!state.installed) {
-    reason = "not-installed";
-  } else if (!state.connected) {
-    reason = "not-connected";
-  } else if (!sessionL1Address) {
-    reason = "no-session";
-  } else if (!state.localNetworkDetected) {
-    reason = "network-mismatch";
-  } else {
-    const normalizedWallet = state.address?.toLowerCase().trim();
-    const normalizedSession = sessionL1Address?.toLowerCase().trim();
-    matches = normalizedWallet === normalizedSession;
-    if (!matches) reason = "address-mismatch";
-  }
-  return {
-    walletAddress: state.address,
-    sessionAddress: sessionL1Address || void 0,
-    matches,
-    reason
-  };
-}
-
-// src/hooks/sandbox.ts
-import { useQuery as useQuery6, useMutation, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
-import { useEffect as useEffect8 } from "react";
-function useSandboxSessions() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient6();
-  useEffect8(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["sandbox", "sessions"] });
-    return subscribe((event) => {
-      if ([
-        "sandbox-session-created",
-        "sandbox-session-paired",
-        "sandbox-session-expired",
-        "sandbox-session-disconnected"
-      ].includes(event.type)) {
-        sync();
+      const response = await queryFn(client);
+      if (response.ok) {
+        setData(response.data);
+      } else {
+        setError(response);
       }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery6({
-    queryKey: ["sandbox", "sessions"],
-    queryFn: async () => {
-      const baseUrl = config.devServerUrl || "";
-      const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/sessions` : `${baseUrl}/api/walletconnect/sandbox/sessions` : "/api/walletconnect/sandbox/sessions";
-      const res = await apiFetch(url);
-      const json = await res.json();
-      return json.sessions;
-    }
-  });
-}
-function useCreateSandboxSession() {
-  const { config, apiFetch } = useHardKas();
-  const queryClient = useQueryClient6();
-  return useMutation({
-    mutationFn: async () => {
-      const baseUrl = config.devServerUrl || "";
-      const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/create` : `${baseUrl}/api/walletconnect/sandbox/create` : "/api/walletconnect/sandbox/create";
-      const res = await apiFetch(url, { method: "POST" });
-      return await res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["sandbox", "sessions"] });
-    }
-  });
-}
-function usePairSandboxSession() {
-  const { config, apiFetch } = useHardKas();
-  const queryClient = useQueryClient6();
-  return useMutation({
-    mutationFn: async (id) => {
-      const baseUrl = config.devServerUrl || "";
-      const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/pair` : `${baseUrl}/api/walletconnect/sandbox/pair` : "/api/walletconnect/sandbox/pair";
-      const res = await apiFetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ id })
-      });
-      return await res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["sandbox", "sessions"] });
-    }
-  });
-}
-function useDisconnectSandboxSession() {
-  const { config, apiFetch } = useHardKas();
-  const queryClient = useQueryClient6();
-  return useMutation({
-    mutationFn: async (id) => {
-      const baseUrl = config.devServerUrl || "";
-      const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/walletconnect/sandbox/disconnect` : `${baseUrl}/api/walletconnect/sandbox/disconnect` : "/api/walletconnect/sandbox/disconnect";
-      const res = await apiFetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ id })
-      });
-      return await res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["sandbox", "sessions"] });
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
     }
-  });
-}
-
-// src/hooks/contracts.ts
-import { useQuery as useQuery7, useMutation as useMutation2 } from "@tanstack/react-query";
-import { createWalletClient as createWalletClient2, custom as custom2 } from "viem";
-function useIgraReadContract(options) {
-  const { igraClient, config } = useHardKas();
-  const { data: session } = useHardKasSession();
-  return useQuery7({
-    queryKey: [
-      "igra",
-      "read",
-      options.address,
-      options.functionName,
-      options.args,
-      config.igraRpcUrl,
-      session?.name
-    ],
-    queryFn: async () => {
-      return await igraClient.readContract({
-        address: options.address,
-        abi: options.abi,
-        functionName: options.functionName,
-        args: options.args
-      });
-    },
-    enabled: options.enabled ?? true,
-    refetchInterval: options.refetchInterval ?? false
-  });
-}
-function useIgraWriteContract() {
-  const { activeProvider, walletAddress, igraClient } = useHardKas();
-  return useMutation2({
-    mutationFn: async (params) => {
-      let client = params.walletClient;
-      if (!client) {
-        if (!activeProvider) {
-          throw new Error(
-            "No active browser wallet connected and no walletClient was provided."
-          );
-        }
-        if (!walletAddress) {
-          throw new Error("No active account address available on connected wallet.");
-        }
-        client = createWalletClient2({
-          account: walletAddress,
-          chain: igraClient.chain,
-          transport: custom2(activeProvider.provider)
-        });
+  }, [client, ...deps]);
+  useEffect(() => {
+    if (options.enabled) {
+      refetch();
+    }
+  }, [refetch, options.enabled]);
+  return { data, error, loading, refetch };
+}
+
+// src/hooks/useMutation.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+function useMutation(mutationFn) {
+  const client = useHardKAS();
+  const [data, setData] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const execute = useCallback2(async (variables) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await mutationFn(client, variables);
+      if (response.ok) {
+        setData(response.data);
+      } else {
+        setError(response);
       }
-      return await client.writeContract({
-        address: params.address,
-        abi: params.abi,
-        functionName: params.functionName,
-        args: params.args
-      });
-    }
-  });
-}
-function useIgraWaitForReceipt() {
-  const { igraClient } = useHardKas();
-  return useMutation2({
-    mutationFn: async (hash) => {
-      return await igraClient.waitForTransactionReceipt({ hash });
+      return response;
+    } catch (err) {
+      setError(err);
+      return { ok: false, code: "UNEXPECTED_ERROR", message: String(err) };
+    } finally {
+      setLoading(false);
     }
-  });
-}
-
-// src/hooks/overview.ts
-import { useQuery as useQuery8, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
-import { useEffect as useEffect9 } from "react";
-function useOverview() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient7();
-  useEffect9(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "overview"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery8({
-    queryKey: ["hardkas", "overview"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/overview` : `${baseUrl}/api/overview` : "/api/overview";
-        const response = await apiFetch(url);
-        if (!response.ok) return null;
-        return await response.json();
-      } catch (e) {
-        console.error("Failed to fetch overview stats from dev server:", e);
-        return null;
-      }
-    },
-    staleTime: 6e4
-  });
+  }, [client, mutationFn]);
+  return { data, error, loading, execute };
 }
 
-// src/hooks/accounts.ts
-import { useQuery as useQuery9, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
-import { useEffect as useEffect10 } from "react";
-function useAccounts() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient8();
-  useEffect10(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "accounts"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery9({
-    queryKey: ["hardkas", "accounts"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/accounts` : `${baseUrl}/api/accounts` : "/api/accounts";
-        const response = await apiFetch(url);
-        if (!response.ok) return { accounts: [] };
-        const data = await response.json();
-        return data || { accounts: [] };
-      } catch (e) {
-        console.error("Failed to fetch accounts from dev server:", e);
-        return { accounts: [] };
-      }
-    },
-    staleTime: 3e4
-  });
-}
-
-// src/hooks/transactions.ts
-import { useQuery as useQuery10, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
-import { useEffect as useEffect11 } from "react";
-function useTransactions() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient9();
-  useEffect11(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "transactions"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery10({
-    queryKey: ["hardkas", "transactions"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/transactions` : `${baseUrl}/api/transactions` : "/api/transactions";
-        const response = await apiFetch(url);
-        if (!response.ok) return [];
-        const data = await response.json();
-        return data.transactions || [];
-      } catch (e) {
-        console.error("Failed to fetch transactions from dev server:", e);
-        return [];
-      }
-    },
-    staleTime: 1e4
-  });
-}
-function useTransaction(id) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient9();
-  useEffect11(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "transaction", id] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [id, queryClient, subscribe]);
-  return useQuery10({
-    queryKey: ["hardkas", "transaction", id],
-    queryFn: async () => {
-      if (!id) return null;
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/transactions/${id}` : `${baseUrl}/api/transactions/${id}` : `/api/transactions/${id}`;
-        const response = await apiFetch(url);
-        if (!response.ok) return null;
-        return await response.json();
-      } catch (e) {
-        console.error(`Failed to fetch transaction detail for '${id}':`, e);
-        return null;
-      }
-    },
-    enabled: !!id,
-    staleTime: 1e4
-  });
-}
-
-// src/hooks/artifacts.ts
-import { useQuery as useQuery11, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
-import { useEffect as useEffect12 } from "react";
-function useArtifacts(schemaFilter) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient10();
-  useEffect12(() => {
-    const sync = () => queryClient.invalidateQueries({
-      queryKey: ["hardkas", "artifacts", schemaFilter || "all"]
-    });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [schemaFilter, queryClient, subscribe]);
-  return useQuery11({
-    queryKey: ["hardkas", "artifacts", schemaFilter || "all"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const queryParams = schemaFilter ? `?schema=${schemaFilter}` : "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts${queryParams}` : `${baseUrl}/api/artifacts${queryParams}` : `/api/artifacts${queryParams}`;
-        const response = await apiFetch(url);
-        if (!response.ok) return [];
-        const data = await response.json();
-        return data.artifacts || [];
-      } catch (e) {
-        console.error("Failed to fetch artifacts from dev server:", e);
-        return [];
-      }
-    },
-    staleTime: 3e4
-  });
-}
-function useArtifact(id) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient10();
-  useEffect12(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "artifact", id] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [id, queryClient, subscribe]);
-  return useQuery11({
-    queryKey: ["hardkas", "artifact", id],
-    queryFn: async () => {
-      if (!id) return null;
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts/${id}` : `${baseUrl}/api/artifacts/${id}` : `/api/artifacts/${id}`;
-        const response = await apiFetch(url);
-        if (!response.ok) return null;
-        const data = await response.json();
-        return data.artifact || null;
-      } catch (e) {
-        console.error(`Failed to fetch artifact detail for '${id}':`, e);
-        return null;
-      }
-    },
-    enabled: !!id,
-    staleTime: 3e4
-  });
-}
-function useExplain(id) {
-  const { config, apiFetch } = useHardKas();
-  return useQuery11({
-    queryKey: ["hardkas", "explain", id],
-    queryFn: async () => {
-      if (!id) return null;
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts/${id}/explain` : `${baseUrl}/api/artifacts/${id}/explain` : `/api/artifacts/${id}/explain`;
-        const response = await apiFetch(url);
-        if (!response.ok) return null;
-        const data = await response.json();
-        return data.data || null;
-      } catch (e) {
-        console.error(`Failed to explain artifact '${id}':`, e);
-        return null;
-      }
-    },
-    enabled: !!id,
-    staleTime: Infinity
-  });
-}
-function useWorkflow(txId) {
-  return useArtifacts("all");
-}
-
-// src/hooks/replay.ts
-import { useQuery as useQuery12, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
-import { useEffect as useEffect13 } from "react";
-function useReplayStatus() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient11();
-  useEffect13(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "replay"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery12({
-    queryKey: ["hardkas", "replay"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/replay` : `${baseUrl}/api/replay` : "/api/replay";
-        const response = await apiFetch(url);
-        if (!response.ok)
-          return { replays: [], pendingReplays: [], pendingReplay: false };
-        const data = await response.json();
-        const formatReplay = (r) => {
-          return {
-            artifactId: r.artifactId,
-            txId: r.payload?.txId || r.txId,
-            planOk: r.payload?.planOk ?? false,
-            receiptOk: r.payload?.receiptOk ?? false,
-            invariantsOk: r.payload?.invariantsOk ?? false,
-            ok: r.payload?.planOk && r.payload?.receiptOk && r.payload?.invariantsOk ? true : false,
-            checks: r.payload?.checks || {
-              workflowDeterministic: "unknown",
-              consensusValidation: "unknown",
-              l2BridgeCorrectness: "unknown"
-            },
-            errors: r.payload?.errors || [],
-            divergencesCount: r.payload?.divergencesCount || 0,
-            createdAt: r.createdAt || r.timestamp || (/* @__PURE__ */ new Date()).toISOString()
-          };
-        };
-        return {
-          replays: (data.replays || []).map(formatReplay),
-          pendingReplays: data.pendingReplays || [],
-          pendingReplay: data.pendingReplay || false,
-          reason: data.reason
-        };
-      } catch (e) {
-        console.error("Failed to fetch replay status from dev server:", e);
-        return { replays: [], pendingReplays: [], pendingReplay: false };
-      }
-    },
-    staleTime: 3e4
-  });
-}
-function useReplayDetail(txId) {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient11();
-  useEffect13(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "replay", txId] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [txId, queryClient, subscribe]);
-  return useQuery12({
-    queryKey: ["hardkas", "replay", txId],
-    queryFn: async () => {
-      if (!txId) return null;
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/replay/${txId}` : `${baseUrl}/api/replay/${txId}` : `/api/replay/${txId}`;
-        const response = await apiFetch(url);
-        if (!response.ok) return null;
-        const data = await response.json();
-        return data.replay || null;
-      } catch (e) {
-        console.error(`Failed to fetch replay details for transaction '${txId}':`, e);
-        return null;
-      }
-    },
-    enabled: !!txId,
-    staleTime: 3e4
-  });
-}
-function useReplay(id) {
-  const { config, apiFetch } = useHardKas();
-  return useQuery12({
-    queryKey: ["hardkas", "replay-artifact", id],
-    queryFn: async () => {
-      if (!id) return null;
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/artifacts/${id}/replay` : `${baseUrl}/api/artifacts/${id}/replay` : `/api/artifacts/${id}/replay`;
-        const response = await apiFetch(url, { method: "POST" });
-        if (!response.ok) return null;
-        const data = await response.json();
-        return data.data || null;
-      } catch (e) {
-        console.error(`Failed to replay artifact '${id}':`, e);
-        return null;
-      }
-    },
-    enabled: !!id,
-    staleTime: Infinity
-  });
-}
-
-// src/hooks/deployments.ts
-import { useQuery as useQuery13, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
-import { useEffect as useEffect14 } from "react";
-function useDeployments() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient12();
-  useEffect14(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "deployments"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery13({
-    queryKey: ["hardkas", "deployments"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/deployments` : `${baseUrl}/api/deployments` : "/api/deployments";
-        const response = await apiFetch(url);
-        if (!response.ok) return [];
-        const data = await response.json();
-        return data.deployments || [];
-      } catch (e) {
-        console.error("Failed to fetch deployments from dev server:", e);
-        return [];
-      }
-    },
-    staleTime: 3e4
-  });
-}
-
-// src/hooks/activity.ts
-import { useQuery as useQuery14, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
-import { useEffect as useEffect15 } from "react";
-function useActivity() {
-  const { config, subscribe, apiFetch } = useHardKas();
-  const queryClient = useQueryClient13();
-  useEffect15(() => {
-    const sync = () => queryClient.invalidateQueries({ queryKey: ["hardkas", "activity"] });
-    return subscribe((event) => {
-      if (["query-synced", "session-changed"].includes(event.type)) {
-        sync();
-      }
-    });
-  }, [queryClient, subscribe]);
-  return useQuery14({
-    queryKey: ["hardkas", "activity"],
-    queryFn: async () => {
-      try {
-        const baseUrl = config.devServerUrl || "";
-        const url = baseUrl ? baseUrl.endsWith("/") ? `${baseUrl}api/activity` : `${baseUrl}/api/activity` : "/api/activity";
-        const response = await apiFetch(url);
-        if (!response.ok) return [];
-        const data = await response.json();
-        return data.activity || [];
-      } catch (e) {
-        console.error("Failed to fetch activity from dev server:", e);
-        return [];
-      }
-    },
-    staleTime: 5e3
-    // Frequent updates safe because it's local dev
-  });
+// src/hooks/useWallet.ts
+function useWallet(address) {
+  return useQuery(
+    (client) => client.getWallet(address),
+    [address],
+    { enabled: !!address }
+  );
 }
 export {
-  HardKasProvider,
-  useAccounts,
-  useActivity,
-  useArtifact,
-  useArtifacts,
-  useConnectKasWareLocal,
-  useCreateSandboxSession,
-  useDeployments,
-  useDisconnectSandboxSession,
-  useEvents,
-  useExplain,
-  useHardKas,
-  useHardKasHealth,
-  useHardKasSession,
-  useIgraAccount,
-  useIgraBalance,
-  useIgraInjectedAccount,
-  useIgraReadContract,
-  useIgraWaitForReceipt,
-  useIgraWallet,
-  useIgraWriteContract,
-  useKasWareLocal,
-  useKasWareSessionMatch,
-  useKaspaBalance,
-  useKaspaWallet,
-  useLocalIgraWalletClient,
-  useMetaMaskLocal,
-  useOverview,
-  usePairSandboxSession,
-  useReplay,
-  useReplayDetail,
-  useReplayStatus,
-  useSandboxSessions,
-  useSwitchToLocalIgra,
-  useTransaction,
-  useTransactions,
-  useWorkflow
+  HardKASProvider,
+  useHardKAS,
+  useMutation,
+  useQuery,
+  useWallet
 };