@obelyzk/sdk 0.5.0

package/dist/react/index.d.mts

@@ -0,0 +1,1367 @@
+import React, { ReactNode } from 'react';
+import { N as Network, U as HttpConfig, _ as ContractConfig, B as BitSageClient, H as HttpClient, I as ContractClient, aa as ContractRegistry, ac as MiningClient, ae as DashboardClient, ag as BatchClient, aj as PaymentsClient, al as StakingClient, as as WorkersClient, ax as GovernanceClient, aA as StwoClient, aD as TeeClient, av as PrivacyClient, E as ECPoint, bk as PrivacyAsset, bl as PrivateAccount, d as EncryptedBalance, W as WsConfig, a as WebSocketClient, V as JobUpdateEvent, X as WorkerUpdateEvent, Y as NetworkStatsEvent, Z as ProofVerifiedEvent, r as SubmitJobResponse, q as SubmitJobRequest, s as JobStatusResponse, L as ListJobsParams, u as ListJobsResponse, t as JobResult, i as JobStatus, cU as GpuTier, cl as RewardResult, ci as WorkerMiningStats, cj as MiningPoolStatus, cg as StakeTier, cV as StakeInfo, b5 as StakingConfig, b1 as WorkerTier, b8 as WorkerTierBenefits, b9 as UnstakeRequest, cW as WorkerInfo, bd as WorkerProfile, bf as LeaderboardMetric, bg as LeaderboardEntry, bh as RegisterWorkerParams, be as PerformanceData, P as PrivacyKeyPair, bw as StealthAddress, bB as GovernanceProposal, bN as CreateProposalParams, bO as VoteDirection, bC as GovernanceRights, bD as GovernanceStats, bE as PoolBalances, bF as VestingStatus, aH as ValidatorStatusResponse, aJ as GpuMetricsResponse, aK as RewardsInfo, aL as HistoryPeriod, aM as RewardHistoryEntry, aO as JobAnalytics, aP as RecentJob, cX as NetworkStats, aQ as WorkerSummary } from '../tee-CiR0hpfm.mjs';
+
+/**
+ * BitSage Provider
+ * Main context provider for BitSage SDK in React applications
+ */
+
+/**
+ * Wallet configuration for signing transactions
+ */
+interface WalletConfig {
+    /** Account address */
+    address: string;
+    /** Private key for signing (or use external signer) */
+    privateKey?: string;
+}
+/**
+ * BitSage SDK context value
+ */
+interface BitSageContextValue {
+    /** Main BitSage client */
+    client: BitSageClient;
+    /** HTTP client for API calls */
+    http: HttpClient;
+    /** Contract client for on-chain interactions */
+    contract: ContractClient;
+    /** Contract addresses for current network */
+    contracts: ContractRegistry;
+    /** Current network */
+    network: Network;
+    /** Whether wallet is connected */
+    isConnected: boolean;
+    /** Connected wallet address */
+    address: string | null;
+    /** Connect wallet */
+    connect: (wallet: WalletConfig) => void;
+    /** Disconnect wallet */
+    disconnect: () => void;
+    mining: MiningClient;
+    dashboard: DashboardClient;
+    batch: BatchClient;
+    payments: PaymentsClient;
+    staking: StakingClient;
+    workers: WorkersClient;
+    governance: GovernanceClient;
+    stwo: StwoClient;
+    tee: TeeClient;
+}
+/**
+ * BitSage Provider props
+ */
+interface BitSageProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Network to connect to */
+    network?: Network;
+    /** API base URL override */
+    apiUrl?: string;
+    /** RPC URL override */
+    rpcUrl?: string;
+    /** Initial wallet configuration */
+    wallet?: WalletConfig;
+    /** HTTP client config overrides */
+    httpConfig?: Partial<HttpConfig>;
+    /** Contract client config overrides */
+    contractConfig?: Partial<ContractConfig>;
+}
+declare const BitSageContext: React.Context<BitSageContextValue | undefined>;
+/**
+ * BitSage Provider Component
+ *
+ * Provides SDK context to React application including:
+ * - Main BitSage client
+ * - Module-specific clients (mining, staking, etc.)
+ * - Wallet connection management
+ * - Network configuration
+ *
+ * @example
+ * ```tsx
+ * import { BitSageProvider } from '@bitsage/sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <BitSageProvider network="sepolia">
+ *       <MyComponent />
+ *     </BitSageProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function BitSageProvider({ children, network, apiUrl, rpcUrl, wallet: initialWallet, httpConfig, contractConfig, }: BitSageProviderProps): JSX.Element;
+/**
+ * Hook to access BitSage SDK context
+ *
+ * @throws Error if used outside of BitSageProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { client, isConnected, connect } = useBitSage();
+ *
+ *   if (!isConnected) {
+ *     return <button onClick={() => connect({ address: '0x...' })}>Connect</button>;
+ *   }
+ *
+ *   return <div>Connected!</div>;
+ * }
+ * ```
+ */
+declare function useBitSage(): BitSageContextValue;
+/**
+ * Hook to access the main BitSage client
+ */
+declare function useBitSageClient(): BitSageClient;
+/**
+ * Hook to access wallet connection state
+ */
+declare function useWallet(): {
+    isConnected: boolean;
+    address: string | null;
+    connect: (wallet: WalletConfig) => void;
+    disconnect: () => void;
+};
+/**
+ * Hook to access current network
+ */
+declare function useNetwork(): Network;
+/**
+ * Hook to access contract addresses
+ */
+declare function useContracts(): ContractRegistry;
+
+/**
+ * Privacy Provider
+ * Context provider for Obelysk privacy features
+ */
+
+/**
+ * Privacy context value
+ */
+interface PrivacyContextValue {
+    /** Privacy client instance */
+    privacy: PrivacyClient | null;
+    /** Whether privacy keys are loaded */
+    hasKeys: boolean;
+    /** Public key (if loaded) */
+    publicKey: ECPoint | null;
+    /** Whether privacy is initializing */
+    isInitializing: boolean;
+    /** Error message if initialization failed */
+    error: string | null;
+    /** Generate new privacy keys */
+    generateKeys: () => Promise<void>;
+    /** Derive keys from wallet signature */
+    deriveKeysFromWallet: (signature: string) => Promise<void>;
+    /** Load keys from encrypted storage */
+    loadKeys: (password: string) => Promise<boolean>;
+    /** Store keys to encrypted storage */
+    storeKeys: (password: string) => Promise<void>;
+    /** Clear loaded keys */
+    clearKeys: () => void;
+    /** Get decrypted balance for current account */
+    getDecryptedBalance: (asset?: PrivacyAsset) => Promise<bigint | null>;
+    /** Refresh balances */
+    refreshBalances: () => Promise<void>;
+    /** Private account info */
+    account: PrivateAccount | null;
+    /** Encrypted balances by asset */
+    balances: Map<PrivacyAsset, EncryptedBalance>;
+}
+/**
+ * Privacy Provider props
+ */
+interface PrivacyProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** Auto-load keys from storage on mount */
+    autoLoad?: boolean;
+    /** Storage key prefix */
+    storagePrefix?: string;
+}
+declare const PrivacyContext: React.Context<PrivacyContextValue | undefined>;
+/**
+ * Privacy Provider Component
+ *
+ * Provides privacy key management and encrypted balance operations.
+ * Must be used within a BitSageProvider.
+ *
+ * @example
+ * ```tsx
+ * import { BitSageProvider, PrivacyProvider } from '@bitsage/sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <BitSageProvider network="sepolia">
+ *       <PrivacyProvider>
+ *         <PrivacyWallet />
+ *       </PrivacyProvider>
+ *     </BitSageProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function PrivacyProvider({ children, autoLoad, storagePrefix, }: PrivacyProviderProps): JSX.Element;
+/**
+ * Hook to access privacy context
+ *
+ * @throws Error if used outside of PrivacyProvider
+ */
+declare function usePrivacy(): PrivacyContextValue;
+/**
+ * Hook to check if privacy keys are available
+ */
+declare function usePrivacyKeys(): {
+    hasKeys: boolean;
+    publicKey: ECPoint | null;
+    generateKeys: () => Promise<void>;
+    deriveKeysFromWallet: (signature: string) => Promise<void>;
+    clearKeys: () => void;
+};
+/**
+ * Hook to access privacy client (if keys are loaded)
+ */
+declare function usePrivacyClient(): PrivacyClient | null;
+
+/**
+ * WebSocket Provider
+ * Context provider for real-time updates via WebSocket
+ */
+
+/**
+ * Connection state
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * WebSocket context value
+ */
+interface WebSocketContextValue {
+    /** WebSocket client instance */
+    ws: WebSocketClient | null;
+    /** Current connection state */
+    connectionState: ConnectionState;
+    /** Whether connected */
+    isConnected: boolean;
+    /** Last error message */
+    error: string | null;
+    /** Reconnect attempt count */
+    reconnectAttempts: number;
+    /** Connect to WebSocket server */
+    connect: () => Promise<void>;
+    /** Disconnect from WebSocket server */
+    disconnect: () => void;
+    /** Force reconnect */
+    reconnect: () => Promise<void>;
+    /** Subscribe to job updates */
+    subscribeToJob: (jobId: string, callback: (event: JobUpdateEvent) => void) => () => void;
+    /** Subscribe to worker updates */
+    subscribeToWorker: (workerId: string, callback: (event: WorkerUpdateEvent) => void) => () => void;
+    /** Subscribe to network stats */
+    subscribeToNetworkStats: (callback: (event: NetworkStatsEvent) => void) => () => void;
+    /** Subscribe to proof verification events */
+    subscribeToProofVerified: (proofHash: string, callback: (event: ProofVerifiedEvent) => void) => () => void;
+    /** Latest network stats event */
+    latestNetworkStats: NetworkStatsEvent | null;
+}
+/**
+ * WebSocket Provider props
+ */
+interface WebSocketProviderProps {
+    /** Child components */
+    children: ReactNode;
+    /** WebSocket URL override */
+    url?: string;
+    /** Auto-connect on mount */
+    autoConnect?: boolean;
+    /** WebSocket configuration */
+    config?: Partial<WsConfig>;
+}
+declare const WebSocketContext: React.Context<WebSocketContextValue | undefined>;
+/**
+ * WebSocket Provider Component
+ *
+ * Provides real-time WebSocket connection for:
+ * - Job status updates
+ * - Worker status updates
+ * - Network statistics
+ * - Proof verification events
+ *
+ * @example
+ * ```tsx
+ * import { BitSageProvider, WebSocketProvider } from '@bitsage/sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <BitSageProvider network="sepolia">
+ *       <WebSocketProvider autoConnect>
+ *         <Dashboard />
+ *       </WebSocketProvider>
+ *     </BitSageProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function WebSocketProvider({ children, url, autoConnect, config, }: WebSocketProviderProps): JSX.Element;
+/**
+ * Hook to access WebSocket context
+ *
+ * @throws Error if used outside of WebSocketProvider
+ */
+declare function useWebSocket(): WebSocketContextValue;
+/**
+ * Hook to get WebSocket connection state
+ */
+declare function useWebSocketConnection(): {
+    connectionState: ConnectionState;
+    isConnected: boolean;
+    error: string | null;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    reconnect: () => Promise<void>;
+};
+
+/**
+ * Job Hooks
+ * React hooks for job operations
+ */
+
+/**
+ * Mutation state for async operations
+ */
+interface MutationState$4<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Query state for data fetching
+ */
+interface QueryState$6<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to submit a job
+ *
+ * @example
+ * ```tsx
+ * function SubmitJobForm() {
+ *   const { submit, isLoading, data, error } = useSubmitJob();
+ *
+ *   const handleSubmit = async () => {
+ *     await submit({
+ *       job_type: { type: 'ai_inference', model_type: 'llama-7b', batch_size: 1 },
+ *       input_data: btoa('Hello!'),
+ *       max_cost_sage: 100n,
+ *       max_duration_secs: 3600,
+ *       priority: 5,
+ *       require_tee: false,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleSubmit} disabled={isLoading}>
+ *         {isLoading ? 'Submitting...' : 'Submit Job'}
+ *       </button>
+ *       {data && <p>Job ID: {data.job_id}</p>}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSubmitJob(): MutationState$4<SubmitJobResponse> & {
+    submit: (request: SubmitJobRequest) => Promise<SubmitJobResponse>;
+    reset: () => void;
+};
+/**
+ * Hook to get job status
+ *
+ * @param jobId - Job ID to query
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function JobStatus({ jobId }: { jobId: string }) {
+ *   const { data, isLoading, error, refetch } = useJobStatus(jobId);
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
+ *   if (!data) return <p>No job found</p>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Status: {data.status}</p>
+ *       <p>Worker: {data.worker_id || 'Pending'}</p>
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useJobStatus(jobId: string | undefined, options?: {
+    /** Polling interval in ms (0 to disable) */
+    pollingInterval?: number;
+    /** Whether to start fetching immediately */
+    enabled?: boolean;
+}): QueryState$6<JobStatusResponse>;
+/**
+ * Hook to list jobs
+ *
+ * @param params - List parameters
+ *
+ * @example
+ * ```tsx
+ * function JobList() {
+ *   const { data, isLoading, refetch } = useJobs({
+ *     status: 'completed',
+ *     limit: 10,
+ *   });
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *
+ *   return (
+ *     <ul>
+ *       {data?.jobs.map((job) => (
+ *         <li key={job.job_id}>{job.job_id} - {job.status}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useJobs(params?: ListJobsParams): QueryState$6<ListJobsResponse>;
+/**
+ * Hook to wait for job completion
+ *
+ * @param jobId - Job ID to wait for
+ * @param options - Wait options
+ *
+ * @example
+ * ```tsx
+ * function JobWaiter({ jobId }: { jobId: string }) {
+ *   const { result, isWaiting, error, start, cancel } = useWaitForJob(jobId);
+ *
+ *   return (
+ *     <div>
+ *       {isWaiting ? (
+ *         <button onClick={cancel}>Cancel</button>
+ *       ) : (
+ *         <button onClick={start}>Start Waiting</button>
+ *       )}
+ *       {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWaitForJob(jobId: string | undefined, options?: {
+    /** Polling interval in ms */
+    pollInterval?: number;
+    /** Timeout in ms */
+    timeout?: number;
+    /** Auto-start waiting */
+    autoStart?: boolean;
+}): {
+    result: JobResult | null;
+    status: JobStatus | null;
+    isWaiting: boolean;
+    error: Error | null;
+    start: () => void;
+    cancel: () => void;
+};
+/**
+ * Hook to cancel a job
+ *
+ * @example
+ * ```tsx
+ * function CancelButton({ jobId }: { jobId: string }) {
+ *   const { cancel, isLoading, error } = useCancelJob();
+ *
+ *   return (
+ *     <button onClick={() => cancel(jobId)} disabled={isLoading}>
+ *       {isLoading ? 'Cancelling...' : 'Cancel Job'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCancelJob(): MutationState$4<void> & {
+    cancel: (jobId: string) => Promise<void>;
+};
+/**
+ * Hook to get job result
+ *
+ * @param jobId - Job ID to get result for
+ *
+ * @example
+ * ```tsx
+ * function JobResult({ jobId }: { jobId: string }) {
+ *   const { data, isLoading, error } = useJobResult(jobId);
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
+ *   if (!data) return <p>No result yet</p>;
+ *
+ *   return <pre>{atob(data.output_data)}</pre>;
+ * }
+ * ```
+ */
+declare function useJobResult(jobId: string | undefined): QueryState$6<JobResult>;
+
+/**
+ * Mining Hooks
+ * React hooks for mining and rewards operations
+ */
+
+/**
+ * Query state for data fetching
+ */
+interface QueryState$5<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to get mining reward estimate
+ *
+ * @param gpuTier - GPU tier to estimate rewards for
+ *
+ * @example
+ * ```tsx
+ * function RewardEstimate() {
+ *   const { data, isLoading } = useMiningRewardEstimate('DataCenter');
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Estimated reward: {data?.amount.toString()} SAGE</p>
+ *       {data?.capped && <p>Daily cap reached!</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMiningRewardEstimate(gpuTier: GpuTier | undefined): QueryState$5<RewardResult>;
+/**
+ * Hook to get worker mining stats
+ *
+ * @param workerId - Worker ID to get stats for
+ *
+ * @example
+ * ```tsx
+ * function WorkerStats({ workerId }: { workerId: string }) {
+ *   const { data, isLoading } = useWorkerMiningStats(workerId);
+ *
+ *   return (
+ *     <div>
+ *       <p>Total jobs: {data?.total_jobs.toString()}</p>
+ *       <p>Total earned: {data?.total_earned.toString()} SAGE</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWorkerMiningStats(workerId: string | undefined): QueryState$5<WorkerMiningStats>;
+/**
+ * Hook to get mining pool status
+ *
+ * @example
+ * ```tsx
+ * function PoolStatus() {
+ *   const { data, isLoading, refetch } = useMiningPoolStatus();
+ *
+ *   return (
+ *     <div>
+ *       <p>Total distributed: {data?.totalDistributed.toString()}</p>
+ *       <p>Remaining pool: {data?.remainingPool.toString()}</p>
+ *       <p>Current base reward: {data?.currentBaseReward.toString()}</p>
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMiningPoolStatus(): QueryState$5<MiningPoolStatus>;
+/**
+ * Hook to get daily cap for a stake tier
+ *
+ * @param stakeTier - Stake tier to get cap for
+ *
+ * @example
+ * ```tsx
+ * function DailyCap({ tier }: { tier: StakeTier }) {
+ *   const { data, isLoading } = useDailyCap(tier);
+ *
+ *   return <p>Daily cap: {data?.toString() || 'Loading...'}</p>;
+ * }
+ * ```
+ */
+declare function useDailyCap(stakeTier: StakeTier | undefined): QueryState$5<bigint>;
+/**
+ * Hook to get current base reward
+ *
+ * @example
+ * ```tsx
+ * function BaseReward() {
+ *   const { data, isLoading } = useCurrentBaseReward();
+ *
+ *   return <p>Base reward: {data?.toString() || 'Loading...'} SAGE</p>;
+ * }
+ * ```
+ */
+declare function useCurrentBaseReward(): QueryState$5<bigint>;
+/**
+ * Hook to get GPU multiplier
+ *
+ * @param gpuTier - GPU tier to get multiplier for
+ *
+ * @example
+ * ```tsx
+ * function GpuMultiplier({ tier }: { tier: GpuTier }) {
+ *   const { data } = useGpuMultiplier(tier);
+ *
+ *   return <p>Multiplier: {data?.toFixed(2) || '1.00'}x</p>;
+ * }
+ * ```
+ */
+declare function useGpuMultiplier(gpuTier: GpuTier | undefined): QueryState$5<number>;
+/**
+ * Hook to get remaining daily cap for a worker
+ *
+ * @param workerAddress - Worker address
+ *
+ * @example
+ * ```tsx
+ * function RemainingCap({ address }: { address: string }) {
+ *   const { data, isLoading } = useRemainingDailyCap(address);
+ *
+ *   return <p>Remaining today: {data?.toString() || '...'} SAGE</p>;
+ * }
+ * ```
+ */
+declare function useRemainingDailyCap(workerAddress: string | undefined): QueryState$5<bigint>;
+/**
+ * Combined hook for mining overview
+ *
+ * @param workerId - Optional worker ID for worker-specific stats
+ *
+ * @example
+ * ```tsx
+ * function MiningOverview({ workerId }: { workerId?: string }) {
+ *   const { poolStatus, workerStats, baseReward, isLoading } = useMiningOverview(workerId);
+ *
+ *   return (
+ *     <div>
+ *       <p>Pool remaining: {poolStatus?.remainingPool.toString()}</p>
+ *       <p>Base reward: {baseReward?.toString()}</p>
+ *       {workerStats && <p>Your earnings: {workerStats.total_earned.toString()}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMiningOverview(workerId?: string): {
+    poolStatus: MiningPoolStatus | null;
+    workerStats: WorkerMiningStats | null;
+    baseReward: bigint | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+/**
+ * Staking Hooks
+ * React hooks for staking operations
+ */
+
+/**
+ * Query state for data fetching
+ */
+interface QueryState$4<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Mutation state for async operations
+ */
+interface MutationState$3<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Transaction result
+ */
+interface TxResult$3 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+/**
+ * Hook to get stake info for an address
+ *
+ * @param address - Address to get stake info for
+ *
+ * @example
+ * ```tsx
+ * function StakeInfo({ address }: { address: string }) {
+ *   const { data, isLoading } = useStakeInfo(address);
+ *
+ *   return (
+ *     <div>
+ *       <p>Staked: {data?.amount.toString()} SAGE</p>
+ *       <p>GPU Tier: {data?.gpu_tier}</p>
+ *       <p>Active: {data?.is_active ? 'Yes' : 'No'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useStakeInfo(address: string | undefined): QueryState$4<StakeInfo>;
+/**
+ * Hook to stake tokens
+ *
+ * @example
+ * ```tsx
+ * function StakeForm() {
+ *   const { stake, isLoading, error } = useStake();
+ *
+ *   const handleStake = async () => {
+ *     await stake(1000n * 10n ** 18n, 'DataCenter');
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleStake} disabled={isLoading}>
+ *       {isLoading ? 'Staking...' : 'Stake 1000 SAGE'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useStake(): MutationState$3<TxResult$3> & {
+    stake: (amount: bigint, gpuTier: GpuTier) => Promise<TxResult$3>;
+    stakeWithTee: (amount: bigint, gpuTier: GpuTier, hasTee: boolean) => Promise<TxResult$3>;
+};
+/**
+ * Hook to unstake tokens
+ *
+ * @example
+ * ```tsx
+ * function UnstakeForm() {
+ *   const { unstake, isLoading } = useUnstake();
+ *
+ *   return (
+ *     <button onClick={() => unstake(500n * 10n ** 18n)} disabled={isLoading}>
+ *       Unstake 500 SAGE
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUnstake(): MutationState$3<TxResult$3> & {
+    unstake: (amount: bigint) => Promise<TxResult$3>;
+};
+/**
+ * Hook to claim staking rewards
+ *
+ * @example
+ * ```tsx
+ * function ClaimButton() {
+ *   const { claim, isLoading, data } = useClaimRewards();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={claim} disabled={isLoading}>
+ *         {isLoading ? 'Claiming...' : 'Claim Rewards'}
+ *       </button>
+ *       {data && <p>Claimed! TX: {data.transaction_hash}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useClaimRewards(): MutationState$3<TxResult$3> & {
+    claim: () => Promise<TxResult$3>;
+};
+/**
+ * Hook to get staking configuration
+ *
+ * @example
+ * ```tsx
+ * function StakingConfig() {
+ *   const { data } = useStakingConfig();
+ *
+ *   return (
+ *     <div>
+ *       <p>Min stake (Consumer): {data?.minStake.Consumer.toString()}</p>
+ *       <p>Unstake lockup: {data?.unstakeLockupSecs}s</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useStakingConfig(): QueryState$4<StakingConfig>;
+/**
+ * Hook to get worker tier
+ *
+ * @param workerAddress - Worker address
+ *
+ * @example
+ * ```tsx
+ * function WorkerTierDisplay({ address }: { address: string }) {
+ *   const { data } = useWorkerTier(address);
+ *
+ *   return <p>Worker Tier: {data || 'Loading...'}</p>;
+ * }
+ * ```
+ */
+declare function useWorkerTier(workerAddress: string | undefined): QueryState$4<WorkerTier>;
+/**
+ * Hook to get worker tier benefits
+ *
+ * @param tier - Worker tier
+ *
+ * @example
+ * ```tsx
+ * function TierBenefits({ tier }: { tier: WorkerTier }) {
+ *   const { data } = useWorkerTierBenefits(tier);
+ *
+ *   return (
+ *     <div>
+ *       <p>Fee discount: {data?.feeDiscountBps}bps</p>
+ *       <p>Priority boost: {data?.priorityBoost}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWorkerTierBenefits(tier: WorkerTier | undefined): QueryState$4<WorkerTierBenefits>;
+/**
+ * Hook to get minimum stake for a GPU tier
+ *
+ * @param gpuTier - GPU tier
+ * @param hasTee - Whether worker has TEE
+ * @param reputation - Worker reputation score
+ *
+ * @example
+ * ```tsx
+ * function MinStake() {
+ *   const { data } = useMinStake('DataCenter', true, 95);
+ *
+ *   return <p>Minimum stake: {data?.toString()} SAGE</p>;
+ * }
+ * ```
+ */
+declare function useMinStake(gpuTier: GpuTier | undefined, hasTee?: boolean, reputation?: number): QueryState$4<bigint>;
+/**
+ * Hook to get pending unstake requests
+ *
+ * @param address - Address to get requests for
+ *
+ * @example
+ * ```tsx
+ * function PendingUnstakes({ address }: { address: string }) {
+ *   const { data, isLoading } = usePendingUnstakes(address);
+ *
+ *   return (
+ *     <ul>
+ *       {data?.map((req) => (
+ *         <li key={req.request_id.toString()}>
+ *           {req.amount.toString()} SAGE - unlocks at {new Date(req.unlock_time * 1000).toLocaleString()}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function usePendingUnstakes(address: string | undefined): QueryState$4<UnstakeRequest[]>;
+/**
+ * Hook to delegate stake to a worker
+ *
+ * @example
+ * ```tsx
+ * function DelegateForm() {
+ *   const { delegate, isLoading } = useDelegateStake();
+ *
+ *   return (
+ *     <button onClick={() => delegate('0x...worker', 100n * 10n ** 18n)}>
+ *       Delegate 100 SAGE
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDelegateStake(): MutationState$3<TxResult$3> & {
+    delegate: (worker: string, amount: bigint) => Promise<TxResult$3>;
+};
+/**
+ * Hook to get total staked amount
+ *
+ * @example
+ * ```tsx
+ * function TotalStaked() {
+ *   const { data } = useTotalStaked();
+ *
+ *   return <p>Total staked: {data?.toString()} SAGE</p>;
+ * }
+ * ```
+ */
+declare function useTotalStaked(): QueryState$4<bigint>;
+/**
+ * Combined hook for current user's staking status
+ *
+ * @example
+ * ```tsx
+ * function MyStaking() {
+ *   const { address } = useWallet();
+ *   const { stakeInfo, tier, pendingUnstakes, isLoading } = useMyStaking();
+ *
+ *   return (
+ *     <div>
+ *       <p>Staked: {stakeInfo?.amount.toString()}</p>
+ *       <p>Tier: {tier}</p>
+ *       <p>Pending unstakes: {pendingUnstakes?.length || 0}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMyStaking(): {
+    stakeInfo: StakeInfo | null;
+    tier: WorkerTier | null;
+    pendingUnstakes: UnstakeRequest[] | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+/**
+ * Worker Hooks
+ * React hooks for worker operations
+ */
+
+interface QueryState$3<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface MutationState$2<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+interface TxResult$2 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+/**
+ * Hook to list all workers
+ */
+declare function useWorkers(options?: {
+    pollingInterval?: number;
+}): QueryState$3<WorkerInfo[]>;
+/**
+ * Hook to get worker by ID
+ */
+declare function useWorker(workerId: string | undefined): QueryState$3<WorkerInfo>;
+/**
+ * Hook to get worker profile
+ */
+declare function useWorkerProfile(workerId: string | undefined): QueryState$3<WorkerProfile>;
+/**
+ * Hook to get worker leaderboard
+ */
+declare function useLeaderboard(metric?: LeaderboardMetric, limit?: number): QueryState$3<LeaderboardEntry[]>;
+/**
+ * Hook to register as a worker
+ */
+declare function useRegisterWorker(): MutationState$2<TxResult$2> & {
+    register: (params: RegisterWorkerParams) => Promise<TxResult$2>;
+};
+/**
+ * Hook to submit worker heartbeat
+ */
+declare function useHeartbeat(): MutationState$2<TxResult$2> & {
+    submitHeartbeat: (data: PerformanceData) => Promise<TxResult$2>;
+};
+/**
+ * Hook to get workers by capability
+ */
+declare function useWorkersByCapability(flags: number, minReputation?: number): QueryState$3<string[]>;
+
+/**
+ * Privacy Hooks
+ * React hooks for privacy operations (uses PrivacyProvider)
+ */
+
+interface QueryState$2<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface MutationState$1<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+interface TxResult$1 {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+/**
+ * Hook to get private account info
+ */
+declare function usePrivateAccount(): QueryState$2<PrivateAccount>;
+/**
+ * Hook to get decrypted private balance
+ */
+declare function usePrivateBalance(asset?: PrivacyAsset): QueryState$2<bigint> & {
+    encrypted: EncryptedBalance | null;
+};
+/** Transfer parameters for private transfers */
+interface PrivateTransferInput {
+    to: string;
+    amount: bigint;
+    keys: PrivacyKeyPair;
+}
+/**
+ * Hook for private transfers
+ */
+declare function usePrivateTransfer(): MutationState$1<TxResult$1> & {
+    transfer: (params: PrivateTransferInput) => Promise<TxResult$1>;
+};
+/**
+ * Hook to register a private account
+ */
+declare function useRegisterPrivateAccount(): MutationState$1<TxResult$1> & {
+    register: () => Promise<TxResult$1>;
+};
+/**
+ * Hook to generate stealth address
+ */
+declare function useStealthAddress(): {
+    generate: (recipientPublicKey: {
+        x: bigint;
+        y: bigint;
+    }) => Promise<StealthAddress>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to refresh all private balances
+ */
+declare function useRefreshPrivateBalances(): {
+    refresh: () => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to get all private balances
+ */
+declare function useAllPrivateBalances(): {
+    balances: Map<PrivacyAsset, {
+        encrypted: EncryptedBalance;
+        decrypted: bigint | null;
+    }>;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+
+/**
+ * Governance Hooks
+ * React hooks for governance operations
+ */
+
+interface QueryState$1<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface MutationState<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+interface TxResult {
+    transaction_hash: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+/**
+ * Hook to get a governance proposal
+ */
+declare function useProposal(proposalId: bigint | undefined): QueryState$1<GovernanceProposal>;
+/**
+ * Hook to list all proposals
+ */
+declare function useProposals(): QueryState$1<GovernanceProposal[]>;
+/**
+ * Hook to create a proposal
+ */
+declare function useCreateProposal(): MutationState<TxResult> & {
+    create: (params: CreateProposalParams) => Promise<TxResult>;
+};
+/**
+ * Hook to vote on a proposal
+ */
+declare function useVote(): MutationState<TxResult> & {
+    vote: (proposalId: bigint, direction: VoteDirection) => Promise<TxResult>;
+};
+/**
+ * Hook to get voting power
+ */
+declare function useVotingPower(address: string | undefined): QueryState$1<bigint>;
+/**
+ * Hook to get governance rights
+ */
+declare function useGovernanceRights(address: string | undefined): QueryState$1<GovernanceRights>;
+/**
+ * Hook to delegate voting power
+ */
+declare function useDelegate(): MutationState<TxResult> & {
+    delegate: (delegatee: string) => Promise<TxResult>;
+};
+/**
+ * Hook to get governance stats
+ */
+declare function useGovernanceStats(): QueryState$1<GovernanceStats>;
+/**
+ * Hook to get pool balances (treasury, rewards, etc.)
+ */
+declare function usePoolBalances(): QueryState$1<PoolBalances>;
+/**
+ * Hook to get total burned tokens
+ */
+declare function useTotalBurned(): QueryState$1<bigint>;
+/**
+ * Hook to get vesting status
+ */
+declare function useVestingStatus(): QueryState$1<VestingStatus>;
+
+/**
+ * Dashboard Hooks
+ * React hooks for dashboard and metrics
+ */
+
+interface QueryState<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to get validator status
+ */
+declare function useValidatorStatus(options?: {
+    pollingInterval?: number;
+}): QueryState<ValidatorStatusResponse>;
+/**
+ * Hook to get GPU metrics
+ */
+declare function useGpuMetrics(options?: {
+    pollingInterval?: number;
+}): QueryState<GpuMetricsResponse>;
+/**
+ * Hook to get rewards info
+ */
+declare function useRewardsInfo(): QueryState<RewardsInfo>;
+/**
+ * Hook to get rewards history
+ */
+declare function useRewardsHistory(period?: HistoryPeriod): QueryState<RewardHistoryEntry[]>;
+/**
+ * Hook to get job analytics
+ */
+declare function useJobAnalytics(): QueryState<JobAnalytics>;
+/**
+ * Hook to get recent jobs
+ */
+declare function useRecentJobs(limit?: number): QueryState<RecentJob[]>;
+/**
+ * Hook to get network stats
+ */
+declare function useNetworkStats(options?: {
+    pollingInterval?: number;
+}): QueryState<NetworkStats>;
+/**
+ * Hook to get network workers
+ */
+declare function useNetworkWorkers(): QueryState<WorkerSummary[]>;
+/**
+ * Combined dashboard hook for validator overview
+ */
+declare function useValidatorOverview(options?: {
+    pollingInterval?: number;
+}): {
+    status: ValidatorStatusResponse | null;
+    gpuMetrics: GpuMetricsResponse | null;
+    rewards: RewardsInfo | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+/**
+ * WebSocket Hooks
+ * React hooks for real-time WebSocket subscriptions
+ */
+
+/**
+ * Hook to subscribe to job updates
+ *
+ * @param jobId - Job ID to subscribe to
+ *
+ * @example
+ * ```tsx
+ * function JobProgress({ jobId }: { jobId: string }) {
+ *   const { event, isSubscribed } = useJobUpdates(jobId);
+ *
+ *   return (
+ *     <div>
+ *       <p>Status: {event?.status || 'Waiting...'}</p>
+ *       {event?.progress && <p>Progress: {event.progress}%</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useJobUpdates(jobId: string | undefined): {
+    event: JobUpdateEvent | null;
+    isSubscribed: boolean;
+    history: JobUpdateEvent[];
+};
+/**
+ * Hook to subscribe to worker updates
+ *
+ * @param workerId - Worker ID to subscribe to
+ *
+ * @example
+ * ```tsx
+ * function WorkerStatus({ workerId }: { workerId: string }) {
+ *   const { event } = useWorkerUpdates(workerId);
+ *
+ *   return (
+ *     <div>
+ *       <p>Online: {event?.online ? 'Yes' : 'No'}</p>
+ *       <p>Load: {event?.load || 0}%</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWorkerUpdates(workerId: string | undefined): {
+    event: WorkerUpdateEvent | null;
+    isSubscribed: boolean;
+};
+/**
+ * Hook to subscribe to network stats updates
+ *
+ * @example
+ * ```tsx
+ * function NetworkDashboard() {
+ *   const { stats } = useNetworkStatsStream();
+ *
+ *   return (
+ *     <div>
+ *       <p>Active workers: {stats?.active_workers || 0}</p>
+ *       <p>Jobs in queue: {stats?.jobs_pending || 0}</p>
+ *       <p>Total FLOPS: {stats?.total_flops || '0'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useNetworkStatsStream(): {
+    stats: NetworkStatsEvent | null;
+    isSubscribed: boolean;
+};
+/**
+ * Hook to subscribe to proof verification events
+ *
+ * @param proofHash - Proof hash to subscribe to
+ *
+ * @example
+ * ```tsx
+ * function ProofStatus({ proofHash }: { proofHash: string }) {
+ *   const { event, isVerified } = useProofVerified(proofHash);
+ *
+ *   return (
+ *     <div>
+ *       {isVerified ? (
+ *         <p>Proof verified at block {event?.block_number}</p>
+ *       ) : (
+ *         <p>Waiting for verification...</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useProofVerified(proofHash: string | undefined): {
+    event: ProofVerifiedEvent | null;
+    isVerified: boolean;
+    isSubscribed: boolean;
+};
+/**
+ * Hook to subscribe to multiple jobs
+ *
+ * @param jobIds - Array of job IDs to subscribe to
+ *
+ * @example
+ * ```tsx
+ * function BatchJobProgress({ jobIds }: { jobIds: string[] }) {
+ *   const { events, completedCount } = useMultipleJobUpdates(jobIds);
+ *
+ *   return (
+ *     <div>
+ *       <p>Completed: {completedCount} / {jobIds.length}</p>
+ *       {Object.entries(events).map(([id, event]) => (
+ *         <p key={id}>{id}: {event?.status}</p>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMultipleJobUpdates(jobIds: string[]): {
+    events: Record<string, JobUpdateEvent | null>;
+    completedCount: number;
+    failedCount: number;
+};
+/**
+ * Hook to get real-time metrics with smoothing
+ *
+ * @example
+ * ```tsx
+ * function SmoothMetrics() {
+ *   const { currentValue, average, trend } = useSmoothedNetworkStats('jobs_pending');
+ *
+ *   return (
+ *     <div>
+ *       <p>Current: {currentValue}</p>
+ *       <p>Avg (30s): {average.toFixed(2)}</p>
+ *       <p>Trend: {trend > 0 ? '↑' : trend < 0 ? '↓' : '→'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSmoothedNetworkStats(metric: keyof NetworkStatsEvent, windowSize?: number): {
+    currentValue: number;
+    average: number;
+    trend: number;
+};
+
+export { BitSageContext, type BitSageContextValue, BitSageProvider, type BitSageProviderProps, type ConnectionState, PrivacyContext, type PrivacyContextValue, PrivacyProvider, type PrivacyProviderProps, type WalletConfig, WebSocketContext, type WebSocketContextValue, WebSocketProvider, type WebSocketProviderProps, 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 };