@obelyzk/sdk 0.5.0

package/dist/react/index.mjs

@@ -0,0 +1,2600 @@
+import {
+  BatchClient,
+  BitSageClient,
+  ContractClient,
+  DashboardClient,
+  GovernanceClient,
+  HttpClient,
+  MiningClient,
+  PaymentsClient,
+  PrivacyClient,
+  PrivacyKeyManager,
+  StakingClient,
+  StwoClient,
+  TeeClient,
+  WebSocketClient,
+  WorkersClient,
+  getContractsForNetwork
+} from "../chunk-LXJT3QK6.mjs";
+import "../chunk-O2PF7VJA.mjs";
+
+// src/react/providers/BitSageProvider.tsx
+import {
+  createContext,
+  useContext,
+  useMemo,
+  useCallback,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var BitSageContext = createContext(void 0);
+function getDefaultApiUrl(network) {
+  switch (network) {
+    case "mainnet":
+      return "https://api.bitsage.network";
+    case "sepolia":
+      return "https://api.sepolia.bitsage.network";
+    case "local":
+      return "http://localhost:8080";
+    default:
+      return "https://api.sepolia.bitsage.network";
+  }
+}
+function getDefaultRpcUrl(network) {
+  switch (network) {
+    case "mainnet":
+      return "https://starknet-mainnet.public.blastapi.io";
+    case "sepolia":
+      return "https://starknet-sepolia.public.blastapi.io";
+    case "local":
+      return "http://localhost:5050";
+    default:
+      return "https://starknet-sepolia.public.blastapi.io";
+  }
+}
+function BitSageProvider({
+  children,
+  network = "sepolia",
+  apiUrl,
+  rpcUrl,
+  wallet: initialWallet,
+  httpConfig,
+  contractConfig
+}) {
+  const [walletState, setWalletState] = useState(
+    initialWallet || null
+  );
+  const resolvedApiUrl = apiUrl || getDefaultApiUrl(network);
+  const resolvedRpcUrl = rpcUrl || getDefaultRpcUrl(network);
+  const contracts = useMemo(() => getContractsForNetwork(network), [network]);
+  const http = useMemo(
+    () => new HttpClient({
+      baseUrl: resolvedApiUrl,
+      ...httpConfig
+    }),
+    [resolvedApiUrl, httpConfig]
+  );
+  const contract = useMemo(() => {
+    const config = {
+      rpcUrl: resolvedRpcUrl,
+      network,
+      ...contractConfig
+    };
+    if (walletState) {
+      config.accountAddress = walletState.address;
+      if (walletState.privateKey) {
+        config.privateKey = walletState.privateKey;
+      }
+    }
+    return new ContractClient(config);
+  }, [resolvedRpcUrl, network, walletState, contractConfig]);
+  const client = useMemo(() => {
+    const config = {
+      apiUrl: resolvedApiUrl,
+      starknetRpcUrl: resolvedRpcUrl,
+      timeout: 3e4,
+      network
+    };
+    return new BitSageClient(config);
+  }, [resolvedApiUrl, resolvedRpcUrl, network]);
+  const mining = useMemo(
+    () => new MiningClient(http, contract, {
+      contractAddress: contracts.miningRewards
+    }),
+    [http, contract, contracts]
+  );
+  const dashboard = useMemo(
+    () => new DashboardClient(http),
+    [http]
+  );
+  const batch = useMemo(
+    () => new BatchClient(http),
+    [http]
+  );
+  const payments = useMemo(
+    () => new PaymentsClient(http, contract, {
+      paymentRouterAddress: contracts.paymentRouter,
+      proofGatedPaymentAddress: contracts.proofGatedPayment
+    }),
+    [http, contract, contracts]
+  );
+  const staking = useMemo(
+    () => new StakingClient(http, contract, {
+      proverStakingAddress: contracts.proverStaking,
+      cdcPoolAddress: contracts.cdcPool
+    }),
+    [http, contract, contracts]
+  );
+  const workers = useMemo(
+    () => new WorkersClient(http, contract, {
+      cdcPoolAddress: contracts.cdcPool,
+      reputationManagerAddress: contracts.reputationManager
+    }),
+    [http, contract, contracts]
+  );
+  const governance = useMemo(
+    () => new GovernanceClient(http, contract, {
+      sageTokenAddress: contracts.sageToken,
+      governanceAddress: contracts.sageToken
+      // Governance is part of token contract
+    }),
+    [http, contract, contracts]
+  );
+  const stwo = useMemo(
+    () => new StwoClient(http, contract, {
+      stwoVerifierAddress: contracts.stwoVerifier,
+      optimisticTeeAddress: contracts.optimisticTee
+    }),
+    [http, contract, contracts]
+  );
+  const tee = useMemo(
+    () => new TeeClient(http, contract, {
+      optimisticTeeAddress: contracts.optimisticTee
+    }),
+    [http, contract, contracts]
+  );
+  const connect = useCallback((wallet) => {
+    setWalletState(wallet);
+  }, []);
+  const disconnect = useCallback(() => {
+    setWalletState(null);
+  }, []);
+  const value = useMemo(
+    () => ({
+      client,
+      http,
+      contract,
+      contracts,
+      network,
+      isConnected: walletState !== null,
+      address: walletState?.address || null,
+      connect,
+      disconnect,
+      mining,
+      dashboard,
+      batch,
+      payments,
+      staking,
+      workers,
+      governance,
+      stwo,
+      tee
+    }),
+    [
+      client,
+      http,
+      contract,
+      contracts,
+      network,
+      walletState,
+      connect,
+      disconnect,
+      mining,
+      dashboard,
+      batch,
+      payments,
+      staking,
+      workers,
+      governance,
+      stwo,
+      tee
+    ]
+  );
+  return /* @__PURE__ */ jsx(BitSageContext.Provider, { value, children });
+}
+function useBitSage() {
+  const context = useContext(BitSageContext);
+  if (context === void 0) {
+    throw new Error("useBitSage must be used within a BitSageProvider");
+  }
+  return context;
+}
+function useBitSageClient() {
+  const { client } = useBitSage();
+  return client;
+}
+function useWallet() {
+  const { isConnected, address, connect, disconnect } = useBitSage();
+  return { isConnected, address, connect, disconnect };
+}
+function useNetwork() {
+  const { network } = useBitSage();
+  return network;
+}
+function useContracts() {
+  const { contracts } = useBitSage();
+  return contracts;
+}
+
+// src/react/providers/PrivacyProvider.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useMemo as useMemo2,
+  useState as useState2,
+  useCallback as useCallback2,
+  useEffect as useEffect2
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PrivacyContext = createContext2(void 0);
+function PrivacyProvider({
+  children,
+  autoLoad = false,
+  storagePrefix = "bitsage_privacy"
+}) {
+  const { http, contract, contracts, address } = useBitSage();
+  const [keyPair, setKeyPair] = useState2(null);
+  const [isInitializing, setIsInitializing] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [account, setAccount] = useState2(null);
+  const [balances, setBalances] = useState2(
+    /* @__PURE__ */ new Map()
+  );
+  const privacy = useMemo2(() => {
+    if (!keyPair) return null;
+    return new PrivacyClient(http, contract, {
+      privacyRouterAddress: contracts.privacyRouter,
+      mixingPoolAddress: contracts.privacyRouter
+    });
+  }, [http, contract, contracts, keyPair]);
+  const generateKeys = useCallback2(async () => {
+    setIsInitializing(true);
+    setError(null);
+    try {
+      const newKeyPair = await PrivacyKeyManager.generate();
+      setKeyPair(newKeyPair);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to generate keys");
+      throw err;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, []);
+  const deriveKeysFromWallet = useCallback2(async (signature) => {
+    setIsInitializing(true);
+    setError(null);
+    try {
+      const derivedKeyPair = await PrivacyKeyManager.deriveFromSignature(signature);
+      setKeyPair(derivedKeyPair);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to derive keys");
+      throw err;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, []);
+  const loadKeys = useCallback2(
+    async (password) => {
+      setIsInitializing(true);
+      setError(null);
+      try {
+        const storageKey = address ? `${storagePrefix}_${address}` : storagePrefix;
+        const loadedKeyPair = await PrivacyKeyManager.retrieve(
+          password,
+          { prefix: storageKey }
+        );
+        if (loadedKeyPair) {
+          setKeyPair(loadedKeyPair);
+          return true;
+        }
+        return false;
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load keys");
+        return false;
+      } finally {
+        setIsInitializing(false);
+      }
+    },
+    [address, storagePrefix]
+  );
+  const storeKeys = useCallback2(
+    async (password) => {
+      if (!keyPair) {
+        throw new Error("No keys to store");
+      }
+      try {
+        const storageKey = address ? `${storagePrefix}_${address}` : storagePrefix;
+        await PrivacyKeyManager.store(keyPair, password, { prefix: storageKey });
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to store keys");
+        throw err;
+      }
+    },
+    [keyPair, address, storagePrefix]
+  );
+  const clearKeys = useCallback2(() => {
+    setKeyPair(null);
+    setAccount(null);
+    setBalances(/* @__PURE__ */ new Map());
+    setError(null);
+  }, []);
+  const getDecryptedBalance = useCallback2(
+    async (asset = "SAGE") => {
+      if (!privacy || !keyPair || !address) return null;
+      try {
+        const multiBalances = await privacy.getPrivateBalances(address);
+        const encryptedBalance = multiBalances[asset];
+        if (!encryptedBalance) return null;
+        const decrypted = await privacy.revealBalance(
+          encryptedBalance,
+          keyPair.privateKey
+        );
+        return decrypted;
+      } catch (err) {
+        console.error("Failed to decrypt balance:", err);
+        return null;
+      }
+    },
+    [privacy, keyPair, address]
+  );
+  const refreshBalances = useCallback2(async () => {
+    if (!privacy || !address) return;
+    try {
+      const multiBalances = await privacy.getPrivateBalances(address);
+      const newBalances = /* @__PURE__ */ new Map();
+      const assets = ["SAGE", "USDC", "STRK", "WBTC", "ETH"];
+      for (const asset of assets) {
+        const balance = multiBalances[asset];
+        if (balance) {
+          newBalances.set(asset, balance);
+        }
+      }
+      setBalances(newBalances);
+    } catch (err) {
+      console.error("Failed to refresh balances:", err);
+    }
+  }, [privacy, address]);
+  useEffect2(() => {
+    if (!privacy || !address) {
+      setAccount(null);
+      return;
+    }
+    let cancelled = false;
+    async function loadAccount() {
+      try {
+        const accountInfo = await privacy.getAccount(address);
+        if (!cancelled) {
+          setAccount(accountInfo);
+        }
+      } catch (err) {
+        console.error("Failed to load private account:", err);
+      }
+    }
+    loadAccount();
+    return () => {
+      cancelled = true;
+    };
+  }, [privacy, address]);
+  useEffect2(() => {
+    if (!autoLoad || !address) return;
+    const storageKey = `${storagePrefix}_${address}`;
+    const hasStoredKeys = typeof localStorage !== "undefined" && localStorage.getItem(storageKey) !== null;
+    if (hasStoredKeys) {
+      console.info("Privacy keys found in storage, call loadKeys() to decrypt");
+    }
+  }, [autoLoad, address, storagePrefix]);
+  const value = useMemo2(
+    () => ({
+      privacy,
+      hasKeys: keyPair !== null,
+      publicKey: keyPair?.publicKey || null,
+      isInitializing,
+      error,
+      generateKeys,
+      deriveKeysFromWallet,
+      loadKeys,
+      storeKeys,
+      clearKeys,
+      getDecryptedBalance,
+      refreshBalances,
+      account,
+      balances
+    }),
+    [
+      privacy,
+      keyPair,
+      isInitializing,
+      error,
+      generateKeys,
+      deriveKeysFromWallet,
+      loadKeys,
+      storeKeys,
+      clearKeys,
+      getDecryptedBalance,
+      refreshBalances,
+      account,
+      balances
+    ]
+  );
+  return /* @__PURE__ */ jsx2(PrivacyContext.Provider, { value, children });
+}
+function usePrivacy() {
+  const context = useContext2(PrivacyContext);
+  if (context === void 0) {
+    throw new Error("usePrivacy must be used within a PrivacyProvider");
+  }
+  return context;
+}
+function usePrivacyKeys() {
+  const {
+    hasKeys,
+    publicKey,
+    generateKeys,
+    deriveKeysFromWallet,
+    clearKeys
+  } = usePrivacy();
+  return {
+    hasKeys,
+    publicKey,
+    generateKeys,
+    deriveKeysFromWallet,
+    clearKeys
+  };
+}
+function usePrivacyClient() {
+  const { privacy } = usePrivacy();
+  return privacy;
+}
+
+// src/react/providers/WebSocketProvider.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useMemo as useMemo3,
+  useState as useState3,
+  useCallback as useCallback3,
+  useEffect as useEffect3,
+  useRef
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var WebSocketContext = createContext3(void 0);
+function getDefaultWsUrl(network) {
+  switch (network) {
+    case "mainnet":
+      return "wss://ws.bitsage.network";
+    case "sepolia":
+      return "wss://ws.sepolia.bitsage.network";
+    case "local":
+      return "ws://localhost:8081";
+    default:
+      return "wss://ws.sepolia.bitsage.network";
+  }
+}
+function WebSocketProvider({
+  children,
+  url,
+  autoConnect = true,
+  config
+}) {
+  const { network } = useBitSage();
+  const [connectionState, setConnectionState] = useState3("disconnected");
+  const [error, setError] = useState3(null);
+  const [reconnectAttempts, setReconnectAttempts] = useState3(0);
+  const [latestNetworkStats, setLatestNetworkStats] = useState3(null);
+  const wsRef = useRef(null);
+  const unsubscribersRef = useRef(/* @__PURE__ */ new Map());
+  const wsUrl = url || getDefaultWsUrl(network);
+  useEffect3(() => {
+    const ws = new WebSocketClient({
+      url: wsUrl,
+      reconnect: true,
+      reconnectIntervalMs: 1e3,
+      maxReconnectAttempts: 10,
+      heartbeatIntervalMs: 3e4,
+      ...config
+    });
+    wsRef.current = ws;
+    ws.onReconnect(() => {
+      setReconnectAttempts((prev) => prev + 1);
+    });
+    ws.onError((err) => {
+      setError(err.message);
+      setConnectionState("error");
+    });
+    return () => {
+      unsubscribersRef.current.forEach((unsubscribe) => unsubscribe());
+      unsubscribersRef.current.clear();
+      ws.disconnect();
+      wsRef.current = null;
+    };
+  }, [wsUrl, config]);
+  const connect = useCallback3(async () => {
+    const ws = wsRef.current;
+    if (!ws) return;
+    setConnectionState("connecting");
+    setError(null);
+    try {
+      await ws.connect();
+      setConnectionState("connected");
+      setReconnectAttempts(0);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Connection failed");
+      setConnectionState("error");
+      throw err;
+    }
+  }, []);
+  const disconnect = useCallback3(() => {
+    const ws = wsRef.current;
+    if (!ws) return;
+    ws.disconnect();
+    setConnectionState("disconnected");
+    setError(null);
+  }, []);
+  const reconnect = useCallback3(async () => {
+    disconnect();
+    await connect();
+  }, [connect, disconnect]);
+  const subscribeToJob = useCallback3(
+    (jobId, callback) => {
+      const ws = wsRef.current;
+      if (!ws) {
+        console.warn("WebSocket not initialized");
+        return () => {
+        };
+      }
+      const unsubscribe = ws.subscribeToJobUpdates(jobId, callback);
+      const key = `job_${jobId}`;
+      unsubscribersRef.current.set(key, unsubscribe);
+      return () => {
+        unsubscribe();
+        unsubscribersRef.current.delete(key);
+      };
+    },
+    []
+  );
+  const subscribeToWorker = useCallback3(
+    (workerId, callback) => {
+      const ws = wsRef.current;
+      if (!ws) {
+        console.warn("WebSocket not initialized");
+        return () => {
+        };
+      }
+      const unsubscribe = ws.subscribeToWorkerUpdates(workerId, callback);
+      const key = `worker_${workerId}`;
+      unsubscribersRef.current.set(key, unsubscribe);
+      return () => {
+        unsubscribe();
+        unsubscribersRef.current.delete(key);
+      };
+    },
+    []
+  );
+  const subscribeToNetworkStats = useCallback3(
+    (callback) => {
+      const ws = wsRef.current;
+      if (!ws) {
+        console.warn("WebSocket not initialized");
+        return () => {
+        };
+      }
+      const wrappedCallback = (event) => {
+        setLatestNetworkStats(event);
+        callback(event);
+      };
+      const unsubscribe = ws.subscribeToNetworkStats(wrappedCallback);
+      const key = "network_stats";
+      unsubscribersRef.current.set(key, unsubscribe);
+      return () => {
+        unsubscribe();
+        unsubscribersRef.current.delete(key);
+      };
+    },
+    []
+  );
+  const subscribeToProofVerified = useCallback3(
+    (proofHash, callback) => {
+      const ws = wsRef.current;
+      if (!ws) {
+        console.warn("WebSocket not initialized");
+        return () => {
+        };
+      }
+      const unsubscribe = ws.subscribeToProofVerified(proofHash, callback);
+      const key = `proof_${proofHash}`;
+      unsubscribersRef.current.set(key, unsubscribe);
+      return () => {
+        unsubscribe();
+        unsubscribersRef.current.delete(key);
+      };
+    },
+    []
+  );
+  useEffect3(() => {
+    if (autoConnect && wsRef.current) {
+      connect().catch((err) => {
+        console.error("Auto-connect failed:", err);
+      });
+    }
+  }, [autoConnect, connect]);
+  const value = useMemo3(
+    () => ({
+      ws: wsRef.current,
+      connectionState,
+      isConnected: connectionState === "connected",
+      error,
+      reconnectAttempts,
+      connect,
+      disconnect,
+      reconnect,
+      subscribeToJob,
+      subscribeToWorker,
+      subscribeToNetworkStats,
+      subscribeToProofVerified,
+      latestNetworkStats
+    }),
+    [
+      connectionState,
+      error,
+      reconnectAttempts,
+      connect,
+      disconnect,
+      reconnect,
+      subscribeToJob,
+      subscribeToWorker,
+      subscribeToNetworkStats,
+      subscribeToProofVerified,
+      latestNetworkStats
+    ]
+  );
+  return /* @__PURE__ */ jsx3(WebSocketContext.Provider, { value, children });
+}
+function useWebSocket() {
+  const context = useContext3(WebSocketContext);
+  if (context === void 0) {
+    throw new Error("useWebSocket must be used within a WebSocketProvider");
+  }
+  return context;
+}
+function useWebSocketConnection() {
+  const {
+    connectionState,
+    isConnected,
+    error,
+    connect,
+    disconnect,
+    reconnect
+  } = useWebSocket();
+  return {
+    connectionState,
+    isConnected,
+    error,
+    connect,
+    disconnect,
+    reconnect
+  };
+}
+
+// src/react/hooks/useJobs.ts
+import { useState as useState4, useCallback as useCallback4, useEffect as useEffect4, useRef as useRef2 } from "react";
+function useSubmitJob() {
+  const { client } = useBitSage();
+  const [state, setState] = useState4({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const submit = useCallback4(
+    async (request) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await client.submitJob(request);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to submit job");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [client]
+  );
+  const reset = useCallback4(() => {
+    setState({ data: null, isLoading: false, error: null });
+  }, []);
+  return { ...state, submit, reset };
+}
+function useJobStatus(jobId, options) {
+  const { client } = useBitSage();
+  const [state, setState] = useState4({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const { pollingInterval = 0, enabled = true } = options || {};
+  const intervalRef = useRef2(null);
+  const fetch = useCallback4(async () => {
+    if (!jobId) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await client.getJobStatus(jobId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch job status");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [client, jobId]);
+  useEffect4(() => {
+    if (enabled && jobId) {
+      fetch();
+    }
+  }, [enabled, jobId, fetch]);
+  useEffect4(() => {
+    if (pollingInterval > 0 && enabled && jobId) {
+      intervalRef.current = setInterval(fetch, pollingInterval);
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [pollingInterval, enabled, jobId, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useJobs(params) {
+  const { client } = useBitSage();
+  const [state, setState] = useState4({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback4(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await client.listJobs(params);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to list jobs");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [client, params]);
+  useEffect4(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useWaitForJob(jobId, options) {
+  const { client } = useBitSage();
+  const [result, setResult] = useState4(null);
+  const [status, setStatus] = useState4(null);
+  const [isWaiting, setIsWaiting] = useState4(false);
+  const [error, setError] = useState4(null);
+  const { pollInterval = 2e3, timeout = 3e5, autoStart = false } = options || {};
+  const abortRef = useRef2(null);
+  const start = useCallback4(() => {
+    if (!jobId || isWaiting) return;
+    setIsWaiting(true);
+    setError(null);
+    setResult(null);
+    abortRef.current = new AbortController();
+    const poll = async () => {
+      const startTime = Date.now();
+      while (!abortRef.current?.signal.aborted) {
+        try {
+          const jobStatus = await client.getJobStatus(jobId);
+          setStatus(jobStatus.status);
+          if (jobStatus.status === "completed") {
+            const jobResult = await client.getJobResult(jobId);
+            setResult(jobResult);
+            setIsWaiting(false);
+            return;
+          }
+          if (jobStatus.status === "failed") {
+            throw new Error("Job failed");
+          }
+          if (jobStatus.status === "cancelled") {
+            throw new Error("Job was cancelled");
+          }
+          if (Date.now() - startTime > timeout) {
+            throw new Error("Timeout waiting for job completion");
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        } catch (err) {
+          if (!abortRef.current?.signal.aborted) {
+            setError(err instanceof Error ? err : new Error("Wait failed"));
+            setIsWaiting(false);
+          }
+          return;
+        }
+      }
+    };
+    poll();
+  }, [client, jobId, isWaiting, pollInterval, timeout]);
+  const cancel = useCallback4(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+    }
+    setIsWaiting(false);
+  }, []);
+  useEffect4(() => {
+    return () => {
+      if (abortRef.current) {
+        abortRef.current.abort();
+      }
+    };
+  }, []);
+  useEffect4(() => {
+    if (autoStart && jobId) {
+      start();
+    }
+  }, [autoStart, jobId, start]);
+  return { result, status, isWaiting, error, start, cancel };
+}
+function useCancelJob() {
+  const { client } = useBitSage();
+  const [state, setState] = useState4({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const cancel = useCallback4(
+    async (jobId) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        await client.cancelJob(jobId);
+        setState({ data: void 0, isLoading: false, error: null });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to cancel job");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [client]
+  );
+  return { ...state, cancel };
+}
+function useJobResult(jobId) {
+  const { client } = useBitSage();
+  const [state, setState] = useState4({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback4(async () => {
+    if (!jobId) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await client.getJobResult(jobId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch job result");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [client, jobId]);
+  useEffect4(() => {
+    if (jobId) {
+      fetch();
+    }
+  }, [jobId, fetch]);
+  return { ...state, refetch: fetch };
+}
+
+// src/react/hooks/useMining.ts
+import { useState as useState5, useCallback as useCallback5, useEffect as useEffect5 } from "react";
+function useMiningRewardEstimate(gpuTier) {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    if (!gpuTier) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getMiningRewardEstimate(gpuTier);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to estimate rewards");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining, gpuTier]);
+  useEffect5(() => {
+    if (gpuTier) {
+      fetch();
+    }
+  }, [gpuTier, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useWorkerMiningStats(workerId) {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    if (!workerId) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getWorkerMiningStats(workerId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch worker stats");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining, workerId]);
+  useEffect5(() => {
+    if (workerId) {
+      fetch();
+    }
+  }, [workerId, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useMiningPoolStatus() {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getMiningPoolStatus();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch pool status");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining]);
+  useEffect5(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useDailyCap(stakeTier) {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    if (!stakeTier) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getDailyCap(stakeTier);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch daily cap");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining, stakeTier]);
+  useEffect5(() => {
+    if (stakeTier) {
+      fetch();
+    }
+  }, [stakeTier, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useCurrentBaseReward() {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getCurrentBaseReward();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch base reward");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining]);
+  useEffect5(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useGpuMultiplier(gpuTier) {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    if (!gpuTier) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getGPUMultiplier(gpuTier);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch GPU multiplier");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining, gpuTier]);
+  useEffect5(() => {
+    if (gpuTier) {
+      fetch();
+    }
+  }, [gpuTier, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useRemainingDailyCap(workerAddress) {
+  const { mining } = useBitSage();
+  const [state, setState] = useState5({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback5(async () => {
+    if (!workerAddress) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await mining.getRemainingDailyCap(workerAddress);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch remaining cap");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [mining, workerAddress]);
+  useEffect5(() => {
+    if (workerAddress) {
+      fetch();
+    }
+  }, [workerAddress, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useMiningOverview(workerId) {
+  const pool = useMiningPoolStatus();
+  const worker = useWorkerMiningStats(workerId);
+  const base = useCurrentBaseReward();
+  const isLoading = pool.isLoading || worker.isLoading || base.isLoading;
+  const error = pool.error || worker.error || base.error;
+  const refetch = useCallback5(async () => {
+    await Promise.all([pool.refetch(), worker.refetch(), base.refetch()]);
+  }, [pool.refetch, worker.refetch, base.refetch]);
+  return {
+    poolStatus: pool.data,
+    workerStats: worker.data,
+    baseReward: base.data,
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// src/react/hooks/useStaking.ts
+import { useState as useState6, useCallback as useCallback6, useEffect as useEffect6 } from "react";
+function useStakeInfo(address) {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    if (!address) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getStakeInfo(address);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch stake info");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking, address]);
+  useEffect6(() => {
+    if (address) {
+      fetch();
+    }
+  }, [address, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useStake() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const stake = useCallback6(
+    async (amount, gpuTier) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await staking.stake(amount, gpuTier);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to stake");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [staking]
+  );
+  const stakeWithTee = useCallback6(
+    async (amount, gpuTier, hasTee) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await staking.stakeWithTEE(amount, gpuTier, hasTee);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to stake with TEE");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [staking]
+  );
+  return { ...state, stake, stakeWithTee };
+}
+function useUnstake() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const unstake = useCallback6(
+    async (amount) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await staking.requestUnstake(amount);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to unstake");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [staking]
+  );
+  return { ...state, unstake };
+}
+function useClaimRewards() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const claim = useCallback6(async () => {
+    setState({ data: null, isLoading: true, error: null });
+    try {
+      const response = await staking.claimRewards();
+      setState({ data: response, isLoading: false, error: null });
+      return response;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to claim rewards");
+      setState({ data: null, isLoading: false, error });
+      throw error;
+    }
+  }, [staking]);
+  return { ...state, claim };
+}
+function useStakingConfig() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getStakingConfig();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch config");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking]);
+  useEffect6(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useWorkerTier(workerAddress) {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    if (!workerAddress) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getWorkerTier(workerAddress);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch worker tier");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking, workerAddress]);
+  useEffect6(() => {
+    if (workerAddress) {
+      fetch();
+    }
+  }, [workerAddress, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useWorkerTierBenefits(tier) {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    if (!tier) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getWorkerTierBenefits(tier);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch tier benefits");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking, tier]);
+  useEffect6(() => {
+    if (tier) {
+      fetch();
+    }
+  }, [tier, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useMinStake(gpuTier, hasTee = false, reputation = 50) {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    if (!gpuTier) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getMinStake(gpuTier, hasTee, reputation);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch min stake");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking, gpuTier, hasTee, reputation]);
+  useEffect6(() => {
+    if (gpuTier) {
+      fetch();
+    }
+  }, [gpuTier, fetch]);
+  return { ...state, refetch: fetch };
+}
+function usePendingUnstakes(address) {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    if (!address) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getUnstakeRequests(address);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch pending unstakes");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking, address]);
+  useEffect6(() => {
+    if (address) {
+      fetch();
+    }
+  }, [address, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useDelegateStake() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const delegate = useCallback6(
+    async (worker, amount) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await staking.delegateStake(worker, amount);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to delegate");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [staking]
+  );
+  return { ...state, delegate };
+}
+function useTotalStaked() {
+  const { staking } = useBitSage();
+  const [state, setState] = useState6({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback6(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await staking.getTotalStaked();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to fetch total staked");
+      setState((prev) => ({ ...prev, isLoading: false, error }));
+    }
+  }, [staking]);
+  useEffect6(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useMyStaking() {
+  const { address } = useBitSage();
+  const stake = useStakeInfo(address || void 0);
+  const tier = useWorkerTier(address || void 0);
+  const pending = usePendingUnstakes(address || void 0);
+  const isLoading = stake.isLoading || tier.isLoading || pending.isLoading;
+  const error = stake.error || tier.error || pending.error;
+  const refetch = useCallback6(async () => {
+    await Promise.all([stake.refetch(), tier.refetch(), pending.refetch()]);
+  }, [stake.refetch, tier.refetch, pending.refetch]);
+  return {
+    stakeInfo: stake.data,
+    tier: tier.data,
+    pendingUnstakes: pending.data,
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// src/react/hooks/useWorkers.ts
+import { useState as useState7, useCallback as useCallback7, useEffect as useEffect7 } from "react";
+function useWorkers(options) {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback7(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await workers.listWorkers();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch workers")
+      }));
+    }
+  }, [workers]);
+  useEffect7(() => {
+    fetch();
+    if (options?.pollingInterval) {
+      const interval = setInterval(fetch, options.pollingInterval);
+      return () => clearInterval(interval);
+    }
+  }, [fetch, options?.pollingInterval]);
+  return { ...state, refetch: fetch };
+}
+function useWorker(workerId) {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback7(async () => {
+    if (!workerId) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await workers.getWorker(workerId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch worker")
+      }));
+    }
+  }, [workers, workerId]);
+  useEffect7(() => {
+    if (workerId) fetch();
+  }, [workerId, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useWorkerProfile(workerId) {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback7(async () => {
+    if (!workerId) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await workers.getWorkerProfile(workerId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch profile")
+      }));
+    }
+  }, [workers, workerId]);
+  useEffect7(() => {
+    if (workerId) fetch();
+  }, [workerId, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useLeaderboard(metric = "reputation", limit = 100) {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback7(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await workers.getLeaderboard(metric, limit);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch leaderboard")
+      }));
+    }
+  }, [workers, metric, limit]);
+  useEffect7(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useRegisterWorker() {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const register = useCallback7(
+    async (params) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await workers.registerWorker(params);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to register");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [workers]
+  );
+  return { ...state, register };
+}
+function useHeartbeat() {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const submitHeartbeat = useCallback7(
+    async (data) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await workers.submitHeartbeat(data);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to submit heartbeat");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [workers]
+  );
+  return { ...state, submitHeartbeat };
+}
+function useWorkersByCapability(flags, minReputation = 0) {
+  const { workers } = useBitSage();
+  const [state, setState] = useState7({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback7(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await workers.getWorkersByCapability(flags, minReputation);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch workers")
+      }));
+    }
+  }, [workers, flags, minReputation]);
+  useEffect7(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+
+// src/react/hooks/usePrivacyHooks.ts
+import { useState as useState8, useCallback as useCallback8, useEffect as useEffect8 } from "react";
+function usePrivateAccount() {
+  const { account, privacy } = usePrivacy();
+  const { address } = useBitSage();
+  const [state, setState] = useState8({
+    data: account,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback8(async () => {
+    if (!privacy || !address) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await privacy.getAccount(address);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch account")
+      }));
+    }
+  }, [privacy, address]);
+  useEffect8(() => {
+    setState((prev) => ({ ...prev, data: account }));
+  }, [account]);
+  return { ...state, refetch: fetch };
+}
+function usePrivateBalance(asset = "SAGE") {
+  const { getDecryptedBalance, balances, hasKeys } = usePrivacy();
+  const [state, setState] = useState8({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback8(async () => {
+    if (!hasKeys) {
+      setState((prev) => ({
+        ...prev,
+        error: new Error("Privacy keys not loaded")
+      }));
+      return;
+    }
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const balance = await getDecryptedBalance(asset);
+      setState((prev) => ({ ...prev, data: balance, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to decrypt balance")
+      }));
+    }
+  }, [getDecryptedBalance, hasKeys, asset]);
+  useEffect8(() => {
+    if (hasKeys) fetch();
+  }, [hasKeys, fetch]);
+  return { ...state, refetch: fetch, encrypted: balances.get(asset) || null };
+}
+function usePrivateTransfer() {
+  const { privacy, hasKeys } = usePrivacy();
+  const [state, setState] = useState8({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const transfer = useCallback8(
+    async (params) => {
+      if (!privacy || !hasKeys) {
+        throw new Error("Privacy not initialized");
+      }
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await privacy.privateTransfer(params);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Transfer failed");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [privacy, hasKeys]
+  );
+  return { ...state, transfer };
+}
+function useRegisterPrivateAccount() {
+  const { privacy, publicKey, hasKeys } = usePrivacy();
+  const [state, setState] = useState8({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const register = useCallback8(async () => {
+    if (!privacy || !hasKeys || !publicKey) {
+      throw new Error("Privacy keys not loaded");
+    }
+    setState({ data: null, isLoading: true, error: null });
+    try {
+      const response = await privacy.registerAccount(publicKey);
+      setState({ data: response, isLoading: false, error: null });
+      return response;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Registration failed");
+      setState({ data: null, isLoading: false, error });
+      throw error;
+    }
+  }, [privacy, publicKey, hasKeys]);
+  return { ...state, register };
+}
+function useStealthAddress() {
+  const { privacy, hasKeys } = usePrivacy();
+  const [isLoading, setIsLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const generate = useCallback8(
+    async (recipientPublicKey) => {
+      if (!privacy || !hasKeys) {
+        throw new Error("Privacy not initialized");
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const address = await privacy.generateStealthAddress(recipientPublicKey);
+        setIsLoading(false);
+        return address;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Generation failed");
+        setError(e);
+        setIsLoading(false);
+        throw e;
+      }
+    },
+    [privacy, hasKeys]
+  );
+  return { generate, isLoading, error };
+}
+function useRefreshPrivateBalances() {
+  const { refreshBalances } = usePrivacy();
+  const [isLoading, setIsLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const refresh = useCallback8(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      await refreshBalances();
+      setIsLoading(false);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error("Refresh failed");
+      setError(e);
+      setIsLoading(false);
+    }
+  }, [refreshBalances]);
+  return { refresh, isLoading, error };
+}
+function useAllPrivateBalances() {
+  const { balances, getDecryptedBalance, hasKeys, refreshBalances } = usePrivacy();
+  const [decryptedBalances, setDecryptedBalances] = useState8(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const loadBalances = useCallback8(async () => {
+    if (!hasKeys) return;
+    setIsLoading(true);
+    setError(null);
+    const newBalances = /* @__PURE__ */ new Map();
+    const assets = ["SAGE", "USDC", "STRK", "WBTC", "ETH"];
+    for (const asset of assets) {
+      const encrypted = balances.get(asset);
+      if (encrypted) {
+        try {
+          const decrypted = await getDecryptedBalance(asset);
+          newBalances.set(asset, { encrypted, decrypted });
+        } catch {
+          newBalances.set(asset, { encrypted, decrypted: null });
+        }
+      }
+    }
+    setDecryptedBalances(newBalances);
+    setIsLoading(false);
+  }, [balances, getDecryptedBalance, hasKeys]);
+  useEffect8(() => {
+    loadBalances();
+  }, [loadBalances]);
+  const refresh = useCallback8(async () => {
+    await refreshBalances();
+    await loadBalances();
+  }, [refreshBalances, loadBalances]);
+  return { balances: decryptedBalances, isLoading, error, refresh };
+}
+
+// src/react/hooks/useGovernance.ts
+import { useState as useState9, useCallback as useCallback9, useEffect as useEffect9 } from "react";
+function useProposal(proposalId) {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    if (proposalId === void 0) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getProposal(proposalId);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch proposal")
+      }));
+    }
+  }, [governance, proposalId]);
+  useEffect9(() => {
+    if (proposalId !== void 0) fetch();
+  }, [proposalId, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useProposals() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.listProposals({ status: "Active" });
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch proposals")
+      }));
+    }
+  }, [governance]);
+  useEffect9(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useCreateProposal() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const create = useCallback9(
+    async (params) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await governance.createProposal(params);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to create proposal");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [governance]
+  );
+  return { ...state, create };
+}
+function useVote() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const vote = useCallback9(
+    async (proposalId, direction) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await governance.vote(proposalId, direction);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to vote");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [governance]
+  );
+  return { ...state, vote };
+}
+function useVotingPower(address) {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    if (!address) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getVotingPower(address);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch voting power")
+      }));
+    }
+  }, [governance, address]);
+  useEffect9(() => {
+    if (address) fetch();
+  }, [address, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useGovernanceRights(address) {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    if (!address) return;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getGovernanceRights(address);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch governance rights")
+      }));
+    }
+  }, [governance, address]);
+  useEffect9(() => {
+    if (address) fetch();
+  }, [address, fetch]);
+  return { ...state, refetch: fetch };
+}
+function useDelegate() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null
+  });
+  const delegate = useCallback9(
+    async (delegatee) => {
+      setState({ data: null, isLoading: true, error: null });
+      try {
+        const response = await governance.delegate(delegatee);
+        setState({ data: response, isLoading: false, error: null });
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to delegate");
+        setState({ data: null, isLoading: false, error });
+        throw error;
+      }
+    },
+    [governance]
+  );
+  return { ...state, delegate };
+}
+function useGovernanceStats() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getGovernanceStats();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch stats")
+      }));
+    }
+  }, [governance]);
+  useEffect9(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function usePoolBalances() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getPoolBalances();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch pool balances")
+      }));
+    }
+  }, [governance]);
+  useEffect9(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useTotalBurned() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getTotalBurned();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch total burned")
+      }));
+    }
+  }, [governance]);
+  useEffect9(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useVestingStatus() {
+  const { governance } = useBitSage();
+  const [state, setState] = useState9({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback9(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await governance.getVestingStatus();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch vesting status")
+      }));
+    }
+  }, [governance]);
+  useEffect9(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+
+// src/react/hooks/useDashboard.ts
+import { useState as useState10, useCallback as useCallback10, useEffect as useEffect10 } from "react";
+function useValidatorStatus(options) {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getValidatorStatus();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch validator status")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+    if (options?.pollingInterval) {
+      const interval = setInterval(fetch, options.pollingInterval);
+      return () => clearInterval(interval);
+    }
+  }, [fetch, options?.pollingInterval]);
+  return { ...state, refetch: fetch };
+}
+function useGpuMetrics(options) {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getGPUMetrics();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch GPU metrics")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+    if (options?.pollingInterval) {
+      const interval = setInterval(fetch, options.pollingInterval);
+      return () => clearInterval(interval);
+    }
+  }, [fetch, options?.pollingInterval]);
+  return { ...state, refetch: fetch };
+}
+function useRewardsInfo() {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getRewardsInfo();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch rewards info")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useRewardsHistory(period = "week") {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getRewardsHistory(period);
+      setState((prev) => ({ ...prev, data: response.entries, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch rewards history")
+      }));
+    }
+  }, [dashboard, period]);
+  useEffect10(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useJobAnalytics() {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getJobAnalytics();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch job analytics")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useRecentJobs(limit = 10) {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getRecentJobs(limit);
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch recent jobs")
+      }));
+    }
+  }, [dashboard, limit]);
+  useEffect10(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useNetworkStats(options) {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getNetworkStats();
+      setState((prev) => ({ ...prev, data: response, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch network stats")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+    if (options?.pollingInterval) {
+      const interval = setInterval(fetch, options.pollingInterval);
+      return () => clearInterval(interval);
+    }
+  }, [fetch, options?.pollingInterval]);
+  return { ...state, refetch: fetch };
+}
+function useNetworkWorkers() {
+  const { dashboard } = useBitSage();
+  const [state, setState] = useState10({
+    data: null,
+    isLoading: false,
+    error: null,
+    refetch: async () => {
+    }
+  });
+  const fetch = useCallback10(async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const response = await dashboard.getNetworkWorkers();
+      setState((prev) => ({ ...prev, data: response.workers, isLoading: false }));
+    } catch (err) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: err instanceof Error ? err : new Error("Failed to fetch network workers")
+      }));
+    }
+  }, [dashboard]);
+  useEffect10(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useValidatorOverview(options) {
+  const status = useValidatorStatus(options);
+  const gpu = useGpuMetrics(options);
+  const rewards = useRewardsInfo();
+  const isLoading = status.isLoading || gpu.isLoading || rewards.isLoading;
+  const error = status.error || gpu.error || rewards.error;
+  const refetch = useCallback10(async () => {
+    await Promise.all([status.refetch(), gpu.refetch(), rewards.refetch()]);
+  }, [status.refetch, gpu.refetch, rewards.refetch]);
+  return {
+    status: status.data,
+    gpuMetrics: gpu.data,
+    rewards: rewards.data,
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+// src/react/hooks/useWebSocketHooks.ts
+import { useState as useState11, useEffect as useEffect11, useRef as useRef3 } from "react";
+function useJobUpdates(jobId) {
+  const { subscribeToJob, isConnected } = useWebSocket();
+  const [event, setEvent] = useState11(null);
+  const [history, setHistory] = useState11([]);
+  const [isSubscribed, setIsSubscribed] = useState11(false);
+  const unsubscribeRef = useRef3(null);
+  useEffect11(() => {
+    if (!jobId || !isConnected) {
+      setIsSubscribed(false);
+      return;
+    }
+    const handleEvent = (e) => {
+      setEvent(e);
+      setHistory((prev) => [...prev, e]);
+    };
+    unsubscribeRef.current = subscribeToJob(jobId, handleEvent);
+    setIsSubscribed(true);
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+      setIsSubscribed(false);
+    };
+  }, [jobId, isConnected, subscribeToJob]);
+  return { event, isSubscribed, history };
+}
+function useWorkerUpdates(workerId) {
+  const { subscribeToWorker, isConnected } = useWebSocket();
+  const [event, setEvent] = useState11(null);
+  const [isSubscribed, setIsSubscribed] = useState11(false);
+  const unsubscribeRef = useRef3(null);
+  useEffect11(() => {
+    if (!workerId || !isConnected) {
+      setIsSubscribed(false);
+      return;
+    }
+    unsubscribeRef.current = subscribeToWorker(workerId, setEvent);
+    setIsSubscribed(true);
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+      setIsSubscribed(false);
+    };
+  }, [workerId, isConnected, subscribeToWorker]);
+  return { event, isSubscribed };
+}
+function useNetworkStatsStream() {
+  const { subscribeToNetworkStats, latestNetworkStats, isConnected } = useWebSocket();
+  const [stats, setStats] = useState11(latestNetworkStats);
+  const [isSubscribed, setIsSubscribed] = useState11(false);
+  const unsubscribeRef = useRef3(null);
+  useEffect11(() => {
+    if (!isConnected) {
+      setIsSubscribed(false);
+      return;
+    }
+    unsubscribeRef.current = subscribeToNetworkStats(setStats);
+    setIsSubscribed(true);
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+      setIsSubscribed(false);
+    };
+  }, [isConnected, subscribeToNetworkStats]);
+  useEffect11(() => {
+    if (latestNetworkStats) {
+      setStats(latestNetworkStats);
+    }
+  }, [latestNetworkStats]);
+  return { stats, isSubscribed };
+}
+function useProofVerified(proofHash) {
+  const { subscribeToProofVerified, isConnected } = useWebSocket();
+  const [event, setEvent] = useState11(null);
+  const [isSubscribed, setIsSubscribed] = useState11(false);
+  const unsubscribeRef = useRef3(null);
+  useEffect11(() => {
+    if (!proofHash || !isConnected) {
+      setIsSubscribed(false);
+      return;
+    }
+    unsubscribeRef.current = subscribeToProofVerified(proofHash, setEvent);
+    setIsSubscribed(true);
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+      setIsSubscribed(false);
+    };
+  }, [proofHash, isConnected, subscribeToProofVerified]);
+  return {
+    event,
+    isVerified: event?.data?.verified ?? false,
+    isSubscribed
+  };
+}
+function useMultipleJobUpdates(jobIds) {
+  const { subscribeToJob, isConnected } = useWebSocket();
+  const [events, setEvents] = useState11({});
+  const unsubscribersRef = useRef3(/* @__PURE__ */ new Map());
+  useEffect11(() => {
+    if (!isConnected) return;
+    for (const jobId of jobIds) {
+      if (!unsubscribersRef.current.has(jobId)) {
+        const unsubscribe = subscribeToJob(jobId, (event) => {
+          setEvents((prev) => ({ ...prev, [jobId]: event }));
+        });
+        unsubscribersRef.current.set(jobId, unsubscribe);
+      }
+    }
+    for (const [jobId, unsubscribe] of unsubscribersRef.current.entries()) {
+      if (!jobIds.includes(jobId)) {
+        unsubscribe();
+        unsubscribersRef.current.delete(jobId);
+        setEvents((prev) => {
+          const next = { ...prev };
+          delete next[jobId];
+          return next;
+        });
+      }
+    }
+    return () => {
+      for (const unsubscribe of unsubscribersRef.current.values()) {
+        unsubscribe();
+      }
+      unsubscribersRef.current.clear();
+    };
+  }, [jobIds, isConnected, subscribeToJob]);
+  const completedCount = Object.values(events).filter(
+    (e) => e?.data?.status === "completed"
+  ).length;
+  const failedCount = Object.values(events).filter(
+    (e) => e?.data?.status === "failed"
+  ).length;
+  return { events, completedCount, failedCount };
+}
+function useSmoothedNetworkStats(metric, windowSize = 10) {
+  const { stats } = useNetworkStatsStream();
+  const [history, setHistory] = useState11([]);
+  useEffect11(() => {
+    if (stats && typeof stats[metric] === "number") {
+      setHistory((prev) => {
+        const next = [...prev, stats[metric]];
+        return next.slice(-windowSize);
+      });
+    }
+  }, [stats, metric, windowSize]);
+  const currentValue = history[history.length - 1] || 0;
+  const average = history.length > 0 ? history.reduce((a, b) => a + b, 0) / history.length : 0;
+  let trend = 0;
+  if (history.length >= 4) {
+    const mid = Math.floor(history.length / 2);
+    const firstHalf = history.slice(0, mid);
+    const secondHalf = history.slice(mid);
+    const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+    const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+    trend = secondAvg - firstAvg;
+  }
+  return { currentValue, average, trend };
+}
+
+// src/react/hooks/useConfidentialSwap.ts
+import { useState as useState12, useCallback as useCallback12, useEffect as useEffect12, useMemo as useMemo4 } from "react";
+export {
+  BitSageContext,
+  BitSageProvider,
+  PrivacyContext,
+  PrivacyProvider,
+  WebSocketContext,
+  WebSocketProvider,
+  useAllPrivateBalances,
+  useBitSage,
+  useBitSageClient,
+  useCancelJob,
+  useClaimRewards,
+  useContracts,
+  useCreateProposal,
+  useCurrentBaseReward,
+  useDailyCap,
+  useDelegate,
+  useDelegateStake,
+  useGovernanceRights,
+  useGovernanceStats,
+  useGpuMetrics,
+  useGpuMultiplier,
+  useHeartbeat,
+  useJobAnalytics,
+  useJobResult,
+  useJobStatus,
+  useJobUpdates,
+  useJobs,
+  useLeaderboard,
+  useMinStake,
+  useMiningOverview,
+  useMiningPoolStatus,
+  useMiningRewardEstimate,
+  useMultipleJobUpdates,
+  useMyStaking,
+  useNetwork,
+  useNetworkStats,
+  useNetworkStatsStream,
+  useNetworkWorkers,
+  usePendingUnstakes,
+  usePoolBalances,
+  usePrivacy,
+  usePrivacyClient,
+  usePrivacyKeys,
+  usePrivateAccount,
+  usePrivateBalance,
+  usePrivateTransfer,
+  useProofVerified,
+  useProposal,
+  useProposals,
+  useRecentJobs,
+  useRefreshPrivateBalances,
+  useRegisterPrivateAccount,
+  useRegisterWorker,
+  useRemainingDailyCap,
+  useRewardsHistory,
+  useRewardsInfo,
+  useSmoothedNetworkStats,
+  useStake,
+  useStakeInfo,
+  useStakingConfig,
+  useStealthAddress,
+  useSubmitJob,
+  useTotalBurned,
+  useTotalStaked,
+  useUnstake,
+  useValidatorOverview,
+  useValidatorStatus,
+  useVestingStatus,
+  useVote,
+  useVotingPower,
+  useWaitForJob,
+  useWallet,
+  useWebSocket,
+  useWebSocketConnection,
+  useWorker,
+  useWorkerMiningStats,
+  useWorkerProfile,
+  useWorkerTier,
+  useWorkerTierBenefits,
+  useWorkerUpdates,
+  useWorkers,
+  useWorkersByCapability
+};