@0xobelisk/react 1.2.0-pre.80 → 1.2.0-pre.83

package/src/sui/provider.tsx

@@ -9,10 +9,19 @@
  * - 📦 Context-based client sharing
  */
 
-import { createContext, useContext, useRef, ReactNode } from 'react';
+import {
+  createContext,
+  useContext,
+  useRef,
+  ReactNode,
+  useState,
+  useCallback,
+  useEffect
+} from 'react';
 import { Dubhe } from '@0xobelisk/sui-client';
 import { createDubheGraphqlClient } from '@0xobelisk/graphql-client';
 import { createECSWorld } from '@0xobelisk/ecs';
+import { DubheGrpcClient } from '@0xobelisk/grpc-client';
 import { useDubheConfig } from './config';
 import type { DubheConfig, DubheReturn } from './types';
 
@@ -23,6 +32,7 @@ import type { DubheConfig, DubheReturn } from './types';
 interface DubheContextValue {
   getContract: () => Dubhe;
   getGraphqlClient: () => any | null;
+  getGrpcClient: () => DubheGrpcClient | null;
   getEcsWorld: () => any | null;
   getAddress: () => string;
   getMetrics: () => {
@@ -31,6 +41,13 @@ interface DubheContextValue {
     lastActivity: number;
   };
   config: DubheConfig;
+  updateConfig: (newConfig: Partial<DubheConfig>) => void;
+  resetClients: (options?: {
+    resetContract?: boolean;
+    resetGraphql?: boolean;
+    resetGrpc?: boolean;
+    resetEcs?: boolean;
+  }) => void;
 }
 
 /**
@@ -88,8 +105,26 @@ interface DubheProviderProps {
  * ```
  */
 export function DubheProvider({ config, children }: DubheProviderProps) {
-  // Merge configuration with defaults (only runs once)
-  const finalConfig = useDubheConfig(config);
+  // Use state to manage config for dynamic updates with persistence
+  const [currentConfig, setCurrentConfig] = useState<Partial<DubheConfig>>(() => {
+    // Try to restore config from localStorage
+    if (typeof window !== 'undefined') {
+      try {
+        const saved = localStorage.getItem('dubhe-config');
+        if (saved) {
+          const parsedConfig = JSON.parse(saved);
+          console.log('Restored Dubhe configuration from localStorage');
+          return { ...config, ...parsedConfig };
+        }
+      } catch (error) {
+        console.warn('Failed to restore Dubhe configuration from localStorage', error);
+      }
+    }
+    return config;
+  });
+
+  // Merge configuration with defaults
+  const finalConfig = useDubheConfig(currentConfig);
 
   // Track initialization start time (useRef ensures single timestamp)
   const startTimeRef = useRef<number>(performance.now());
@@ -136,6 +171,25 @@ export function DubheProvider({ config, children }: DubheProviderProps) {
     return graphqlClientRef.current;
   };
 
+  // useRef for gRPC client instance - single initialization guaranteed
+  const grpcClientRef = useRef<DubheGrpcClient | null>(null);
+  const hasInitializedGrpc = useRef(false);
+  const getGrpcClient = (): DubheGrpcClient | null => {
+    if (!hasInitializedGrpc.current && finalConfig.endpoints?.grpc) {
+      try {
+        console.log('Initializing gRPC client instance (one-time)');
+        grpcClientRef.current = new DubheGrpcClient({
+          baseUrl: finalConfig.endpoints.grpc
+        });
+        hasInitializedGrpc.current = true;
+      } catch (error) {
+        console.error('gRPC client initialization failed:', error);
+        throw error;
+      }
+    }
+    return grpcClientRef.current;
+  };
+
   // useRef for ECS World instance - depends on GraphQL client
   const ecsWorldRef = useRef<any | null>(null);
   const hasInitializedEcs = useRef(false);
@@ -175,14 +229,153 @@ export function DubheProvider({ config, children }: DubheProviderProps) {
     lastActivity: Date.now()
   });
 
+  // Selective reset client instances
+  const resetClients = useCallback(
+    (options?: {
+      resetContract?: boolean;
+      resetGraphql?: boolean;
+      resetGrpc?: boolean;
+      resetEcs?: boolean;
+    }) => {
+      const opts = {
+        resetContract: true,
+        resetGraphql: true,
+        resetGrpc: true,
+        resetEcs: true,
+        ...options
+      };
+
+      console.log('Resetting Dubhe client instances', opts);
+
+      if (opts.resetContract) {
+        contractRef.current = undefined;
+      }
+      if (opts.resetGraphql) {
+        graphqlClientRef.current = null;
+        hasInitializedGraphql.current = false;
+      }
+      if (opts.resetGrpc) {
+        grpcClientRef.current = null;
+        hasInitializedGrpc.current = false;
+      }
+      if (opts.resetEcs) {
+        ecsWorldRef.current = null;
+        hasInitializedEcs.current = false;
+      }
+
+      startTimeRef.current = performance.now();
+    },
+    []
+  );
+
+  // Update config without resetting clients (reactive update)
+  const updateConfig = useCallback((newConfig: Partial<DubheConfig>) => {
+    console.log('Updating Dubhe configuration (reactive)');
+    setCurrentConfig((prev) => {
+      const updated = { ...prev, ...newConfig };
+      // Persist to localStorage
+      if (typeof window !== 'undefined') {
+        try {
+          localStorage.setItem('dubhe-config', JSON.stringify(updated));
+          console.log('Persisted Dubhe configuration to localStorage');
+        } catch (error) {
+          console.warn('Failed to persist Dubhe configuration', error);
+        }
+      }
+      return updated;
+    });
+  }, []);
+
+  // Reactive configuration updates via useEffect
+
+  // Monitor Contract configuration changes
+  useEffect(() => {
+    if (contractRef.current) {
+      console.log('Contract config dependencies changed, updating...');
+      contractRef.current.updateConfig({
+        networkType: finalConfig.network,
+        packageId: finalConfig.packageId,
+        metadata: finalConfig.metadata,
+        secretKey: finalConfig.credentials?.secretKey,
+        mnemonics: finalConfig.credentials?.mnemonics
+      });
+    }
+  }, [
+    finalConfig.network,
+    finalConfig.packageId,
+    finalConfig.metadata,
+    finalConfig.credentials?.secretKey,
+    finalConfig.credentials?.mnemonics
+  ]);
+
+  // Monitor GraphQL endpoint changes
+  useEffect(() => {
+    if (graphqlClientRef.current) {
+      console.log('GraphQL endpoint dependencies changed, updating...');
+      graphqlClientRef.current.updateConfig({
+        endpoint: finalConfig.endpoints?.graphql,
+        subscriptionEndpoint: finalConfig.endpoints?.websocket
+      });
+      // Reset ECS World when GraphQL endpoints change (needs new connection)
+      ecsWorldRef.current = null;
+      hasInitializedEcs.current = false;
+    }
+  }, [finalConfig.endpoints?.graphql, finalConfig.endpoints?.websocket]);
+
+  // Monitor GraphQL metadata changes
+  useEffect(() => {
+    if (graphqlClientRef.current && finalConfig.dubheMetadata) {
+      console.log('GraphQL metadata changed, updating...');
+      graphqlClientRef.current.updateConfig({
+        dubheMetadata: finalConfig.dubheMetadata
+      });
+      // Note: ECS will handle its own metadata update via its useEffect
+    }
+  }, [finalConfig.dubheMetadata]);
+
+  // Monitor gRPC configuration changes
+  useEffect(() => {
+    if (grpcClientRef.current && finalConfig.endpoints?.grpc) {
+      console.log('gRPC config dependencies changed, updating...');
+      grpcClientRef.current.updateConfig({ baseUrl: finalConfig.endpoints.grpc });
+    }
+  }, [finalConfig.endpoints?.grpc]);
+
+  // Monitor ECS configuration changes
+  useEffect(() => {
+    if (ecsWorldRef.current) {
+      console.log('ECS config dependencies changed, updating...');
+      ecsWorldRef.current.updateConfig({
+        dubheMetadata: finalConfig.dubheMetadata,
+        queryConfig: {
+          enableBatchOptimization: finalConfig.options?.enableBatchOptimization,
+          defaultCacheTimeout: finalConfig.options?.cacheTimeout
+        },
+        subscriptionConfig: {
+          defaultDebounceMs: finalConfig.options?.debounceMs,
+          reconnectOnError: finalConfig.options?.reconnectOnError
+        }
+      });
+    }
+  }, [
+    finalConfig.dubheMetadata,
+    finalConfig.options?.enableBatchOptimization,
+    finalConfig.options?.cacheTimeout,
+    finalConfig.options?.debounceMs,
+    finalConfig.options?.reconnectOnError
+  ]);
+
   // Context value - stable reference (no re-renders for consumers)
   const contextValue: DubheContextValue = {
     getContract,
     getGraphqlClient,
+    getGrpcClient,
     getEcsWorld,
     getAddress,
     getMetrics,
-    config: finalConfig
+    config: finalConfig,
+    updateConfig,
+    resetClients
   };
 
   return <DubheContext.Provider value={contextValue}>{children}</DubheContext.Provider>;
@@ -248,6 +441,7 @@ export function useDubheFromProvider(): DubheReturn {
   // Get instances (lazy initialization via getters)
   const contract = context.getContract();
   const graphqlClient = context.getGraphqlClient();
+  const grpcClient = context.getGrpcClient();
   const ecsWorld = context.getEcsWorld();
   const address = context.getAddress();
   const metrics = context.getMetrics();
@@ -300,6 +494,7 @@ export function useDubheFromProvider(): DubheReturn {
   return {
     contract: enhancedContract,
     graphqlClient,
+    grpcClient,
     ecsWorld,
     metadata: context.config.metadata,
     network: context.config.network,
@@ -339,3 +534,43 @@ export function useDubheECSFromProvider(): any | null {
   const { getEcsWorld } = useDubheContext();
   return getEcsWorld();
 }
+
+/**
+ * Hook for accessing only the gRPC client instance
+ */
+export function useDubheGrpcFromProvider(): DubheGrpcClient | null {
+  const { getGrpcClient } = useDubheContext();
+  return getGrpcClient();
+}
+
+/**
+ * Hook for accessing configuration update methods
+ *
+ * @returns Object with updateConfig and resetClients methods
+ *
+ * @example
+ * ```typescript
+ * function ConfigUpdater() {
+ *   const { updateConfig, resetClients, config } = useDubheConfigUpdate();
+ *
+ *   const switchNetwork = () => {
+ *     updateConfig({
+ *       network: 'testnet',
+ *       packageId: '0xnew...'
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Current network: {config.network}</p>
+ *       <button onClick={switchNetwork}>Switch to Testnet</button>
+ *       <button onClick={resetClients}>Reset Clients</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useDubheConfigUpdate() {
+  const { updateConfig, resetClients, config } = useDubheContext();
+  return { updateConfig, resetClients, config };
+}

package/src/sui/types.ts

@@ -1,6 +1,7 @@
 import { SuiMoveNormalizedModules, Dubhe } from '@0xobelisk/sui-client';
 import type { DubheGraphqlClient } from '@0xobelisk/graphql-client';
 import type { DubheECSWorld } from '@0xobelisk/ecs';
+import type { DubheGrpcClient } from '@0xobelisk/grpc-client';
 
 /**
  * Network type
@@ -30,6 +31,7 @@ export interface DubheConfig {
   endpoints?: {
     graphql?: string;
     websocket?: string;
+    grpc?: string;
   };
   /** Performance and behavior options */
   options?: {
@@ -65,6 +67,8 @@ export interface DubheReturn {
   };
   /** GraphQL client (null if dubheMetadata not provided) */
   graphqlClient: DubheGraphqlClient | null;
+  /** gRPC client (null if grpc endpoint not provided) */
+  grpcClient: DubheGrpcClient | null;
   /** ECS World instance (null if GraphQL not available) */
   ecsWorld: DubheECSWorld | null;
   /** Contract metadata */

package/dist/chunk-7KXBMX2H.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sui/config.ts","../src/sui/utils.ts","../src/sui/provider.tsx","../src/sui/hooks.ts"],"sourcesContent":["/**\n * Configuration Management for Dubhe React Integration\n *\n * Features:\n * - Type-safe configuration interface\n * - Configuration validation and error handling\n * - Smart merging of defaults and explicit config\n * - No environment variable handling (developers should handle environment variables themselves)\n */\n\nimport { useMemo } from 'react';\nimport type { DubheConfig } from './types';\nimport { mergeConfigurations, validateConfig } from './utils';\n\n/**\n * Default configuration object with sensible defaults\n */\nexport const DEFAULT_CONFIG: Partial<DubheConfig> = {\n  endpoints: {\n    graphql: 'http://localhost:4000/graphql',\n    websocket: 'ws://localhost:4000/graphql'\n  },\n  options: {\n    enableBatchOptimization: true,\n    cacheTimeout: 5000,\n    debounceMs: 100,\n    reconnectOnError: true\n  }\n};\n\n/**\n * Configuration Hook: useDubheConfig\n *\n * Merges defaults with explicit configuration provided by the developer\n *\n * Note: Environment variables should be handled by the developer before passing to this hook\n *\n * @param config - Complete or partial configuration object\n * @returns Complete, validated DubheConfig\n *\n * @example\n * ```typescript\n * // Basic usage with explicit config\n * const config = useDubheConfig({\n *   network: 'testnet',\n *   packageId: '0x123...',\n *   metadata: contractMetadata,\n *   credentials: {\n *     secretKey: process.env.NEXT_PUBLIC_PRIVATE_KEY // Handle env vars yourself\n *   }\n * });\n *\n * // With helper function to handle environment variables\n * const getConfigFromEnv = () => ({\n *   network: process.env.NEXT_PUBLIC_NETWORK as NetworkType,\n *   packageId: process.env.NEXT_PUBLIC_PACKAGE_ID,\n *   credentials: {\n *     secretKey: process.env.NEXT_PUBLIC_PRIVATE_KEY\n *   }\n * });\n *\n * const config = useDubheConfig({\n *   ...getConfigFromEnv(),\n *   metadata: contractMetadata\n * });\n * ```\n */\nexport function useDubheConfig(config: Partial<DubheConfig>): DubheConfig {\n  // Memoize the stringified config to detect actual changes\n  const configKey = useMemo(() => {\n    return JSON.stringify(config);\n  }, [config]);\n\n  return useMemo(() => {\n    // Merge configurations: defaults -> user provided config\n    const mergedConfig = mergeConfigurations(DEFAULT_CONFIG, config);\n\n    // Validate the final configuration\n    const validatedConfig = validateConfig(mergedConfig);\n\n    // if (process.env.NODE_ENV === 'development') {\n    //   console.log('🔧 Dubhe Config:', {\n    //     ...validatedConfig,\n    //     credentials: validatedConfig.credentials?.secretKey ? '[REDACTED]' : undefined\n    //   });\n    // }\n\n    return validatedConfig;\n  }, [configKey]);\n}\n","/**\n * Utility Functions for Dubhe Configuration Management\n *\n * Features:\n * - Configuration validation and error handling\n * - Smart configuration merging with proper type safety\n * - Type-safe configuration validation\n */\n\nimport type { DubheConfig } from './types';\n\n/**\n * Merge multiple configuration objects with proper deep merging\n * Later configurations override earlier ones\n *\n * @param baseConfig - Base configuration (usually defaults)\n * @param overrideConfig - Override configuration (user provided)\n * @returns Merged configuration\n */\nexport function mergeConfigurations(\n  baseConfig: Partial<DubheConfig>,\n  overrideConfig?: Partial<DubheConfig>\n): Partial<DubheConfig> {\n  if (!overrideConfig) {\n    return { ...baseConfig };\n  }\n\n  const result: Partial<DubheConfig> = { ...baseConfig };\n\n  // Merge top-level properties\n  Object.assign(result, overrideConfig);\n\n  // Deep merge nested objects\n  if (overrideConfig.credentials || baseConfig.credentials) {\n    result.credentials = {\n      ...baseConfig.credentials,\n      ...overrideConfig.credentials\n    };\n  }\n\n  if (overrideConfig.endpoints || baseConfig.endpoints) {\n    result.endpoints = {\n      ...baseConfig.endpoints,\n      ...overrideConfig.endpoints\n    };\n  }\n\n  if (overrideConfig.options || baseConfig.options) {\n    result.options = {\n      ...baseConfig.options,\n      ...overrideConfig.options\n    };\n  }\n\n  return result;\n}\n\n/**\n * Validate configuration and ensure required fields are present\n * Throws descriptive errors for missing required fields\n *\n * @param config - Configuration to validate\n * @returns Validated and typed configuration\n * @throws Error if required fields are missing or invalid\n */\nexport function validateConfig(config: Partial<DubheConfig>): DubheConfig {\n  const errors: string[] = [];\n\n  // Check required fields\n  if (!config.network) {\n    errors.push('network is required');\n  }\n\n  if (!config.packageId) {\n    errors.push('packageId is required');\n  }\n\n  if (!config.metadata) {\n    errors.push('metadata is required');\n  } else {\n    // Basic metadata validation\n    if (typeof config.metadata !== 'object') {\n      errors.push('metadata must be an object');\n    } else if (Object.keys(config.metadata).length === 0) {\n      errors.push('metadata cannot be empty');\n    }\n  }\n\n  // Validate network type\n  if (config.network && !['mainnet', 'testnet', 'devnet', 'localnet'].includes(config.network)) {\n    errors.push(\n      `invalid network: ${config.network}. Must be one of: mainnet, testnet, devnet, localnet`\n    );\n  }\n\n  // Validate package ID format (enhanced check)\n  if (config.packageId) {\n    if (!config.packageId.startsWith('0x')) {\n      errors.push('packageId must start with 0x');\n    } else if (config.packageId.length < 3) {\n      errors.push('packageId must be longer than 0x');\n    } else if (!/^0x[a-fA-F0-9]+$/.test(config.packageId)) {\n      errors.push('packageId must contain only hexadecimal characters after 0x');\n    }\n  }\n\n  // Validate dubheMetadata if provided\n  if (config.dubheMetadata !== undefined) {\n    if (typeof config.dubheMetadata !== 'object' || config.dubheMetadata === null) {\n      errors.push('dubheMetadata must be an object');\n    } else if (!config.dubheMetadata.components && !config.dubheMetadata.resources) {\n      errors.push('dubheMetadata must contain components or resources');\n    }\n  }\n\n  // Validate credentials if provided\n  if (config.credentials) {\n    if (config.credentials.secretKey && typeof config.credentials.secretKey !== 'string') {\n      errors.push('credentials.secretKey must be a string');\n    }\n    if (config.credentials.mnemonics && typeof config.credentials.mnemonics !== 'string') {\n      errors.push('credentials.mnemonics must be a string');\n    }\n  }\n\n  // Validate URLs if provided\n  if (config.endpoints?.graphql && !isValidUrl(config.endpoints.graphql)) {\n    errors.push('endpoints.graphql must be a valid URL');\n  }\n\n  if (config.endpoints?.websocket && !isValidUrl(config.endpoints.websocket)) {\n    errors.push('endpoints.websocket must be a valid URL');\n  }\n\n  // Validate numeric options\n  if (\n    config.options?.cacheTimeout !== undefined &&\n    (typeof config.options.cacheTimeout !== 'number' || config.options.cacheTimeout < 0)\n  ) {\n    errors.push('options.cacheTimeout must be a non-negative number');\n  }\n\n  if (\n    config.options?.debounceMs !== undefined &&\n    (typeof config.options.debounceMs !== 'number' || config.options.debounceMs < 0)\n  ) {\n    errors.push('options.debounceMs must be a non-negative number');\n  }\n\n  if (errors.length > 0) {\n    const errorMessage = `Invalid Dubhe configuration (${errors.length} error${\n      errors.length > 1 ? 's' : ''\n    }):\\n${errors.map((e) => `- ${e}`).join('\\n')}`;\n    console.error('Configuration validation failed:', { errors, config });\n    throw new Error(errorMessage);\n  }\n\n  return config as DubheConfig;\n}\n\n/**\n * Simple URL validation helper\n *\n * @param url - URL string to validate\n * @returns true if URL is valid, false otherwise\n */\nfunction isValidUrl(url: string): boolean {\n  try {\n    new URL(url);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Generate a configuration summary for debugging\n * Hides sensitive information like private keys\n *\n * @param config - Configuration to summarize\n * @returns Safe configuration summary\n */\nexport function getConfigSummary(config: DubheConfig): object {\n  return {\n    network: config.network,\n    packageId: config.packageId,\n    dubheSchemaId: config.dubheSchemaId,\n    hasMetadata: !!config.metadata,\n    hasDubheMetadata: !!config.dubheMetadata,\n    hasCredentials: !!config.credentials?.secretKey,\n    endpoints: config.endpoints,\n    options: config.options\n  };\n}\n","/**\n * Dubhe Provider - useRef Pattern for Client Management\n *\n * Features:\n * - 🎯 Single client instances across application lifecycle\n * - ⚡ useRef-based storage (no re-initialization on re-renders)\n * - 🔧 Provider pattern for dependency injection\n * - 🛡️ Complete type safety with strict TypeScript\n * - 📦 Context-based client sharing\n */\n\nimport { createContext, useContext, useRef, ReactNode } from 'react';\nimport { Dubhe } from '@0xobelisk/sui-client';\nimport { createDubheGraphqlClient } from '@0xobelisk/graphql-client';\nimport { createECSWorld } from '@0xobelisk/ecs';\nimport { useDubheConfig } from './config';\nimport type { DubheConfig, DubheReturn } from './types';\n\n/**\n * Context interface for Dubhe client instances\n * All clients are stored using useRef to ensure single initialization\n */\ninterface DubheContextValue {\n  getContract: () => Dubhe;\n  getGraphqlClient: () => any | null;\n  getEcsWorld: () => any | null;\n  getAddress: () => string;\n  getMetrics: () => {\n    initTime: number;\n    requestCount: number;\n    lastActivity: number;\n  };\n  config: DubheConfig;\n}\n\n/**\n * Context for sharing Dubhe clients across the application\n * Uses useRef pattern to ensure clients are created only once\n */\nconst DubheContext = createContext<DubheContextValue | null>(null);\n\n/**\n * Props interface for DubheProvider component\n */\ninterface DubheProviderProps {\n  /** Configuration for Dubhe initialization */\n  config: Partial<DubheConfig>;\n  /** Child components that will have access to Dubhe clients */\n  children: ReactNode;\n}\n\n/**\n * DubheProvider Component - useRef Pattern Implementation\n *\n * This Provider uses useRef to store client instances, ensuring they are:\n * 1. Created only once during component lifecycle\n * 2. Persisted across re-renders without re-initialization\n * 3. Shared efficiently via React Context\n *\n * Key advantages over useMemo:\n * - useRef guarantees single initialization (useMemo can re-run on dependency changes)\n * - No dependency array needed (eliminates potential re-initialization bugs)\n * - Better performance for heavy client objects\n * - Clearer separation of concerns via Provider pattern\n *\n * @param props - Provider props containing config and children\n * @returns Provider component wrapping children with Dubhe context\n *\n * @example\n * ```typescript\n * // App root setup\n * function App() {\n *   const dubheConfig = {\n *     network: 'devnet',\n *     packageId: '0x123...',\n *     metadata: contractMetadata,\n *     credentials: {\n *       secretKey: process.env.NEXT_PUBLIC_PRIVATE_KEY\n *     }\n *   };\n *\n *   return (\n *     <DubheProvider config={dubheConfig}>\n *       <MyApplication />\n *     </DubheProvider>\n *   );\n * }\n * ```\n */\nexport function DubheProvider({ config, children }: DubheProviderProps) {\n  // Merge configuration with defaults (only runs once)\n  const finalConfig = useDubheConfig(config);\n\n  // Track initialization start time (useRef ensures single timestamp)\n  const startTimeRef = useRef<number>(performance.now());\n\n  // useRef for contract instance - guarantees single initialization\n  // Unlike useMemo, useRef.current is never re-calculated\n  const contractRef = useRef<Dubhe | undefined>(undefined);\n  const getContract = (): Dubhe => {\n    if (!contractRef.current) {\n      try {\n        console.log('Initializing Dubhe contract instance (one-time)');\n        contractRef.current = new Dubhe({\n          networkType: finalConfig.network,\n          packageId: finalConfig.packageId,\n          metadata: finalConfig.metadata,\n          secretKey: finalConfig.credentials?.secretKey\n        });\n      } catch (error) {\n        console.error('Contract initialization failed:', error);\n        throw error;\n      }\n    }\n    return contractRef.current;\n  };\n\n  // useRef for GraphQL client instance - single initialization guaranteed\n  const graphqlClientRef = useRef<any | null>(null);\n  const hasInitializedGraphql = useRef(false);\n  const getGraphqlClient = (): any | null => {\n    if (!hasInitializedGraphql.current && finalConfig.dubheMetadata) {\n      try {\n        console.log('Initializing GraphQL client instance (one-time)');\n        graphqlClientRef.current = createDubheGraphqlClient({\n          endpoint: finalConfig.endpoints?.graphql || 'http://localhost:4000/graphql',\n          subscriptionEndpoint: finalConfig.endpoints?.websocket || 'ws://localhost:4000/graphql',\n          dubheMetadata: finalConfig.dubheMetadata\n        });\n        hasInitializedGraphql.current = true;\n      } catch (error) {\n        console.error('GraphQL client initialization failed:', error);\n        throw error;\n      }\n    }\n    return graphqlClientRef.current;\n  };\n\n  // useRef for ECS World instance - depends on GraphQL client\n  const ecsWorldRef = useRef<any | null>(null);\n  const hasInitializedEcs = useRef(false);\n  const getEcsWorld = (): any | null => {\n    const graphqlClient = getGraphqlClient();\n    if (!hasInitializedEcs.current && graphqlClient) {\n      try {\n        console.log('Initializing ECS World instance (one-time)');\n        ecsWorldRef.current = createECSWorld(graphqlClient, {\n          queryConfig: {\n            enableBatchOptimization: finalConfig.options?.enableBatchOptimization ?? true,\n            defaultCacheTimeout: finalConfig.options?.cacheTimeout ?? 5000\n          },\n          subscriptionConfig: {\n            defaultDebounceMs: finalConfig.options?.debounceMs ?? 100,\n            reconnectOnError: finalConfig.options?.reconnectOnError ?? true\n          }\n        });\n        hasInitializedEcs.current = true;\n      } catch (error) {\n        console.error('ECS World initialization failed:', error);\n        throw error;\n      }\n    }\n    return ecsWorldRef.current;\n  };\n\n  // Address getter - calculated from contract\n  const getAddress = (): string => {\n    return getContract().getAddress();\n  };\n\n  // Metrics getter - performance tracking\n  const getMetrics = () => ({\n    initTime: performance.now() - (startTimeRef.current || 0),\n    requestCount: 0, // Can be enhanced with actual tracking\n    lastActivity: Date.now()\n  });\n\n  // Context value - stable reference (no re-renders for consumers)\n  const contextValue: DubheContextValue = {\n    getContract,\n    getGraphqlClient,\n    getEcsWorld,\n    getAddress,\n    getMetrics,\n    config: finalConfig\n  };\n\n  return <DubheContext.Provider value={contextValue}>{children}</DubheContext.Provider>;\n}\n\n/**\n * Custom hook to access Dubhe context\n * Provides type-safe access to all Dubhe client instances\n *\n * @returns DubheContextValue with all client getters and config\n * @throws Error if used outside of DubheProvider\n *\n * @example\n * ```typescript\n * function MyComponent() {\n *   const dubheContext = useDubheContext();\n *\n *   const contract = dubheContext.getContract();\n *   const graphqlClient = dubheContext.getGraphqlClient();\n *   const ecsWorld = dubheContext.getEcsWorld();\n *   const address = dubheContext.getAddress();\n *\n *   return <div>Connected as {address}</div>;\n * }\n * ```\n */\nexport function useDubheContext(): DubheContextValue {\n  const context = useContext(DubheContext);\n\n  if (!context) {\n    throw new Error(\n      'useDubheContext must be used within a DubheProvider. ' +\n        'Make sure to wrap your app with <DubheProvider config={...}>'\n    );\n  }\n\n  return context;\n}\n\n/**\n * Enhanced hook that mimics the original useDubhe API\n * Uses the Provider pattern internally but maintains backward compatibility\n *\n * @returns DubheReturn object with all instances and metadata\n *\n * @example\n * ```typescript\n * function MyComponent() {\n *   const { contract, graphqlClient, ecsWorld, address } = useDubheFromProvider();\n *\n *   const handleTransaction = async () => {\n *     const tx = new Transaction();\n *     await contract.tx.my_system.my_method({ tx });\n *   };\n *\n *   return <button onClick={handleTransaction}>Execute</button>;\n * }\n * ```\n */\nexport function useDubheFromProvider(): DubheReturn {\n  const context = useDubheContext();\n\n  // Get instances (lazy initialization via getters)\n  const contract = context.getContract();\n  const graphqlClient = context.getGraphqlClient();\n  const ecsWorld = context.getEcsWorld();\n  const address = context.getAddress();\n  const metrics = context.getMetrics();\n\n  // Enhanced contract with additional methods (similar to original implementation)\n  const enhancedContract = contract as any;\n\n  // Add transaction methods with error handling (if not already added)\n  if (!enhancedContract.txWithOptions) {\n    enhancedContract.txWithOptions = (system: string, method: string, options: any = {}) => {\n      return async (params: any) => {\n        try {\n          const startTime = performance.now();\n          const result = await contract.tx[system][method](params);\n          const executionTime = performance.now() - startTime;\n\n          if (process.env.NODE_ENV === 'development') {\n            console.log(\n              `Transaction ${system}.${method} completed in ${executionTime.toFixed(2)}ms`\n            );\n          }\n\n          options.onSuccess?.(result);\n          return result;\n        } catch (error) {\n          options.onError?.(error);\n          throw error;\n        }\n      };\n    };\n  }\n\n  // Add query methods with performance tracking (if not already added)\n  if (!enhancedContract.queryWithOptions) {\n    enhancedContract.queryWithOptions = (system: string, method: string, _options: any = {}) => {\n      return async (params: any) => {\n        const startTime = performance.now();\n        const result = await contract.query[system][method](params);\n        const executionTime = performance.now() - startTime;\n\n        if (process.env.NODE_ENV === 'development') {\n          console.log(`Query ${system}.${method} completed in ${executionTime.toFixed(2)}ms`);\n        }\n\n        return result;\n      };\n    };\n  }\n\n  return {\n    contract: enhancedContract,\n    graphqlClient,\n    ecsWorld,\n    metadata: context.config.metadata,\n    network: context.config.network,\n    packageId: context.config.packageId,\n    dubheSchemaId: context.config.dubheSchemaId,\n    address,\n    options: context.config.options,\n    metrics\n  };\n}\n\n/**\n * Individual client hooks for components that only need specific instances\n * These are more efficient than useDubheFromProvider for single-client usage\n */\n\n/**\n * Hook for accessing only the Dubhe contract instance\n */\nexport function useDubheContractFromProvider(): Dubhe {\n  const { contract } = useDubheFromProvider();\n  return contract;\n}\n\n/**\n * Hook for accessing only the GraphQL client instance\n */\nexport function useDubheGraphQLFromProvider(): any | null {\n  const { getGraphqlClient } = useDubheContext();\n  return getGraphqlClient();\n}\n\n/**\n * Hook for accessing only the ECS World instance\n */\nexport function useDubheECSFromProvider(): any | null {\n  const { getEcsWorld } = useDubheContext();\n  return getEcsWorld();\n}\n","/**\n * Modern Dubhe React Hooks - Provider Pattern\n *\n * Features:\n * - 🎯 Simple API design with Provider pattern\n * - ⚡ Single client initialization with useRef\n * - 🔧 Configuration-driven setup (developers handle environment variables themselves)\n * - 🛡️ Complete type safety with strict TypeScript\n * - 📦 Context-based client sharing across components\n */\nimport { Dubhe } from '@0xobelisk/sui-client';\n\nimport {\n  useDubheFromProvider,\n  useDubheContractFromProvider,\n  useDubheGraphQLFromProvider,\n  useDubheECSFromProvider\n} from './provider';\nimport type { DubheReturn } from './types';\n\n/**\n * Primary Hook: useDubhe\n *\n * Uses Provider pattern to access shared Dubhe clients with guaranteed single initialization.\n * Must be used within a DubheProvider.\n *\n * @returns Complete Dubhe ecosystem with contract, GraphQL, ECS, and metadata\n *\n * @example\n * ```typescript\n * // App setup with Provider\n * function App() {\n *   const config = {\n *     network: 'devnet',\n *     packageId: '0x123...',\n *     metadata: contractMetadata,\n *     credentials: {\n *       secretKey: process.env.NEXT_PUBLIC_PRIVATE_KEY\n *     }\n *   };\n *\n *   return (\n *     <DubheProvider config={config}>\n *       <MyDApp />\n *     </DubheProvider>\n *   );\n * }\n *\n * // Component usage\n * function MyDApp() {\n *   const { contract, address } = useDubhe();\n *   return <div>Connected as {address}</div>;\n * }\n * ```\n */\nexport function useDubhe(): DubheReturn {\n  return useDubheFromProvider();\n}\n\n/**\n * Individual Instance Hook: useDubheContract\n *\n * Returns only the Dubhe contract instance from Provider context.\n * More efficient than useDubhe() when only contract access is needed.\n *\n * @returns Dubhe contract instance\n *\n * @example\n * ```typescript\n * function TransactionComponent() {\n *   const contract = useDubheContract();\n *\n *   const handleTransaction = async () => {\n *     const tx = new Transaction();\n *     await contract.tx.my_system.my_method({ tx });\n *   };\n *\n *   return <button onClick={handleTransaction}>Execute</button>;\n * }\n * ```\n */\nexport function useDubheContract(): Dubhe {\n  return useDubheContractFromProvider();\n}\n\n/**\n * Individual Instance Hook: useDubheGraphQL\n *\n * Returns only the GraphQL client from Provider context.\n * More efficient than useDubhe() when only GraphQL access is needed.\n *\n * @returns GraphQL client instance (null if dubheMetadata not provided)\n *\n * @example\n * ```typescript\n * function DataComponent() {\n *   const graphqlClient = useDubheGraphQL();\n *\n *   useEffect(() => {\n *     if (graphqlClient) {\n *       graphqlClient.query({ ... }).then(setData);\n *     }\n *   }, [graphqlClient]);\n *\n *   return <div>{data && JSON.stringify(data)}</div>;\n * }\n * ```\n */\nexport function useDubheGraphQL(): any | null {\n  return useDubheGraphQLFromProvider();\n}\n\n/**\n * Individual Instance Hook: useDubheECS\n *\n * Returns only the ECS World instance from Provider context.\n * More efficient than useDubhe() when only ECS access is needed.\n *\n * @returns ECS World instance (null if GraphQL client not available)\n *\n * @example\n * ```typescript\n * function ECSComponent() {\n *   const ecsWorld = useDubheECS();\n *\n *   useEffect(() => {\n *     if (ecsWorld) {\n *       ecsWorld.getComponent('MyComponent').then(setComponent);\n *     }\n *   }, [ecsWorld]);\n *\n *   return <div>ECS Component Data</div>;\n * }\n * ```\n */\nexport function useDubheECS(): any | null {\n  return useDubheECSFromProvider();\n}\n\n/**\n * Compatibility alias for useDubhe\n */\nexport const useContract = useDubhe;\n"],"mappings":"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","names":[]}