@0xobelisk/react 1.2.0-pre.64

package/dist/sui/index.js

@@ -0,0 +1,374 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sui/index.ts
+var sui_exports = {};
+__export(sui_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DubheProvider: () => DubheProvider,
+  getConfigSummary: () => getConfigSummary,
+  mergeConfigurations: () => mergeConfigurations,
+  useContract: () => useContract,
+  useDubhe: () => useDubhe,
+  useDubheConfig: () => useDubheConfig,
+  useDubheContract: () => useDubheContract,
+  useDubheECS: () => useDubheECS,
+  useDubheGraphQL: () => useDubheGraphQL,
+  validateConfig: () => validateConfig
+});
+module.exports = __toCommonJS(sui_exports);
+
+// src/sui/config.ts
+var import_react = require("react");
+
+// src/sui/utils.ts
+function mergeConfigurations(baseConfig, overrideConfig) {
+  if (!overrideConfig) {
+    return { ...baseConfig };
+  }
+  const result = { ...baseConfig };
+  Object.assign(result, overrideConfig);
+  if (overrideConfig.credentials || baseConfig.credentials) {
+    result.credentials = {
+      ...baseConfig.credentials,
+      ...overrideConfig.credentials
+    };
+  }
+  if (overrideConfig.endpoints || baseConfig.endpoints) {
+    result.endpoints = {
+      ...baseConfig.endpoints,
+      ...overrideConfig.endpoints
+    };
+  }
+  if (overrideConfig.options || baseConfig.options) {
+    result.options = {
+      ...baseConfig.options,
+      ...overrideConfig.options
+    };
+  }
+  return result;
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.network) {
+    errors.push("network is required");
+  }
+  if (!config.packageId) {
+    errors.push("packageId is required");
+  }
+  if (!config.metadata) {
+    errors.push("metadata is required");
+  } else {
+    if (typeof config.metadata !== "object") {
+      errors.push("metadata must be an object");
+    } else if (Object.keys(config.metadata).length === 0) {
+      errors.push("metadata cannot be empty");
+    }
+  }
+  if (config.network && !["mainnet", "testnet", "devnet", "localnet"].includes(config.network)) {
+    errors.push(
+      `invalid network: ${config.network}. Must be one of: mainnet, testnet, devnet, localnet`
+    );
+  }
+  if (config.packageId) {
+    if (!config.packageId.startsWith("0x")) {
+      errors.push("packageId must start with 0x");
+    } else if (config.packageId.length < 3) {
+      errors.push("packageId must be longer than 0x");
+    } else if (!/^0x[a-fA-F0-9]+$/.test(config.packageId)) {
+      errors.push("packageId must contain only hexadecimal characters after 0x");
+    }
+  }
+  if (config.dubheMetadata !== void 0) {
+    if (typeof config.dubheMetadata !== "object" || config.dubheMetadata === null) {
+      errors.push("dubheMetadata must be an object");
+    } else if (!config.dubheMetadata.components && !config.dubheMetadata.resources) {
+      errors.push("dubheMetadata must contain components or resources");
+    }
+  }
+  if (config.credentials) {
+    if (config.credentials.secretKey && typeof config.credentials.secretKey !== "string") {
+      errors.push("credentials.secretKey must be a string");
+    }
+    if (config.credentials.mnemonics && typeof config.credentials.mnemonics !== "string") {
+      errors.push("credentials.mnemonics must be a string");
+    }
+  }
+  if (config.endpoints?.graphql && !isValidUrl(config.endpoints.graphql)) {
+    errors.push("endpoints.graphql must be a valid URL");
+  }
+  if (config.endpoints?.websocket && !isValidUrl(config.endpoints.websocket)) {
+    errors.push("endpoints.websocket must be a valid URL");
+  }
+  if (config.options?.cacheTimeout !== void 0 && (typeof config.options.cacheTimeout !== "number" || config.options.cacheTimeout < 0)) {
+    errors.push("options.cacheTimeout must be a non-negative number");
+  }
+  if (config.options?.debounceMs !== void 0 && (typeof config.options.debounceMs !== "number" || config.options.debounceMs < 0)) {
+    errors.push("options.debounceMs must be a non-negative number");
+  }
+  if (errors.length > 0) {
+    const errorMessage = `Invalid Dubhe configuration (${errors.length} error${errors.length > 1 ? "s" : ""}):
+${errors.map((e) => `- ${e}`).join("\n")}`;
+    console.error("Configuration validation failed:", { errors, config });
+    throw new Error(errorMessage);
+  }
+  return config;
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getConfigSummary(config) {
+  return {
+    network: config.network,
+    packageId: config.packageId,
+    dubheSchemaId: config.dubheSchemaId,
+    hasMetadata: !!config.metadata,
+    hasDubheMetadata: !!config.dubheMetadata,
+    hasCredentials: !!config.credentials?.secretKey,
+    endpoints: config.endpoints,
+    options: config.options
+  };
+}
+
+// src/sui/config.ts
+var DEFAULT_CONFIG = {
+  endpoints: {
+    graphql: "http://localhost:4000/graphql",
+    websocket: "ws://localhost:4000/graphql"
+  },
+  options: {
+    enableBatchOptimization: true,
+    cacheTimeout: 5e3,
+    debounceMs: 100,
+    reconnectOnError: true
+  }
+};
+function useDubheConfig(config) {
+  const configKey = (0, import_react.useMemo)(() => {
+    return JSON.stringify(config);
+  }, [config]);
+  return (0, import_react.useMemo)(() => {
+    const mergedConfig = mergeConfigurations(DEFAULT_CONFIG, config);
+    const validatedConfig = validateConfig(mergedConfig);
+    return validatedConfig;
+  }, [configKey]);
+}
+
+// src/sui/provider.tsx
+var import_react2 = require("react");
+var import_sui_client = require("@0xobelisk/sui-client");
+var import_graphql_client = require("@0xobelisk/graphql-client");
+var import_ecs = require("@0xobelisk/ecs");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DubheContext = (0, import_react2.createContext)(null);
+function DubheProvider({ config, children }) {
+  const finalConfig = useDubheConfig(config);
+  const startTimeRef = (0, import_react2.useRef)(performance.now());
+  const contractRef = (0, import_react2.useRef)(void 0);
+  const getContract = () => {
+    if (!contractRef.current) {
+      try {
+        console.log("Initializing Dubhe contract instance (one-time)");
+        contractRef.current = new import_sui_client.Dubhe({
+          networkType: finalConfig.network,
+          packageId: finalConfig.packageId,
+          metadata: finalConfig.metadata,
+          secretKey: finalConfig.credentials?.secretKey
+        });
+      } catch (error) {
+        console.error("Contract initialization failed:", error);
+        throw error;
+      }
+    }
+    return contractRef.current;
+  };
+  const graphqlClientRef = (0, import_react2.useRef)(null);
+  const hasInitializedGraphql = (0, import_react2.useRef)(false);
+  const getGraphqlClient = () => {
+    if (!hasInitializedGraphql.current && finalConfig.dubheMetadata) {
+      try {
+        console.log("Initializing GraphQL client instance (one-time)");
+        graphqlClientRef.current = (0, import_graphql_client.createDubheGraphqlClient)({
+          endpoint: finalConfig.endpoints?.graphql || "http://localhost:4000/graphql",
+          subscriptionEndpoint: finalConfig.endpoints?.websocket || "ws://localhost:4000/graphql",
+          dubheMetadata: finalConfig.dubheMetadata
+        });
+        hasInitializedGraphql.current = true;
+      } catch (error) {
+        console.error("GraphQL client initialization failed:", error);
+        throw error;
+      }
+    }
+    return graphqlClientRef.current;
+  };
+  const ecsWorldRef = (0, import_react2.useRef)(null);
+  const hasInitializedEcs = (0, import_react2.useRef)(false);
+  const getEcsWorld = () => {
+    const graphqlClient = getGraphqlClient();
+    if (!hasInitializedEcs.current && graphqlClient) {
+      try {
+        console.log("Initializing ECS World instance (one-time)");
+        ecsWorldRef.current = (0, import_ecs.createECSWorld)(graphqlClient, {
+          queryConfig: {
+            enableBatchOptimization: finalConfig.options?.enableBatchOptimization ?? true,
+            defaultCacheTimeout: finalConfig.options?.cacheTimeout ?? 5e3
+          },
+          subscriptionConfig: {
+            defaultDebounceMs: finalConfig.options?.debounceMs ?? 100,
+            reconnectOnError: finalConfig.options?.reconnectOnError ?? true
+          }
+        });
+        hasInitializedEcs.current = true;
+      } catch (error) {
+        console.error("ECS World initialization failed:", error);
+        throw error;
+      }
+    }
+    return ecsWorldRef.current;
+  };
+  const getAddress = () => {
+    return getContract().getAddress();
+  };
+  const getMetrics = () => ({
+    initTime: performance.now() - (startTimeRef.current || 0),
+    requestCount: 0,
+    // Can be enhanced with actual tracking
+    lastActivity: Date.now()
+  });
+  const contextValue = {
+    getContract,
+    getGraphqlClient,
+    getEcsWorld,
+    getAddress,
+    getMetrics,
+    config: finalConfig
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DubheContext.Provider, { value: contextValue, children });
+}
+function useDubheContext() {
+  const context = (0, import_react2.useContext)(DubheContext);
+  if (!context) {
+    throw new Error(
+      "useDubheContext must be used within a DubheProvider. Make sure to wrap your app with <DubheProvider config={...}>"
+    );
+  }
+  return context;
+}
+function useDubheFromProvider() {
+  const context = useDubheContext();
+  const contract = context.getContract();
+  const graphqlClient = context.getGraphqlClient();
+  const ecsWorld = context.getEcsWorld();
+  const address = context.getAddress();
+  const metrics = context.getMetrics();
+  const enhancedContract = contract;
+  if (!enhancedContract.txWithOptions) {
+    enhancedContract.txWithOptions = (system, method, options = {}) => {
+      return async (params) => {
+        try {
+          const startTime = performance.now();
+          const result = await contract.tx[system][method](params);
+          const executionTime = performance.now() - startTime;
+          if (process.env.NODE_ENV === "development") {
+            console.log(
+              `Transaction ${system}.${method} completed in ${executionTime.toFixed(2)}ms`
+            );
+          }
+          options.onSuccess?.(result);
+          return result;
+        } catch (error) {
+          options.onError?.(error);
+          throw error;
+        }
+      };
+    };
+  }
+  if (!enhancedContract.queryWithOptions) {
+    enhancedContract.queryWithOptions = (system, method, options = {}) => {
+      return async (params) => {
+        const startTime = performance.now();
+        const result = await contract.query[system][method](params);
+        const executionTime = performance.now() - startTime;
+        if (process.env.NODE_ENV === "development") {
+          console.log(`Query ${system}.${method} completed in ${executionTime.toFixed(2)}ms`);
+        }
+        return result;
+      };
+    };
+  }
+  return {
+    contract: enhancedContract,
+    graphqlClient,
+    ecsWorld,
+    metadata: context.config.metadata,
+    network: context.config.network,
+    packageId: context.config.packageId,
+    dubheSchemaId: context.config.dubheSchemaId,
+    address,
+    options: context.config.options,
+    metrics
+  };
+}
+function useDubheContractFromProvider() {
+  const { contract } = useDubheFromProvider();
+  return contract;
+}
+function useDubheGraphQLFromProvider() {
+  const { getGraphqlClient } = useDubheContext();
+  return getGraphqlClient();
+}
+function useDubheECSFromProvider() {
+  const { getEcsWorld } = useDubheContext();
+  return getEcsWorld();
+}
+
+// src/sui/hooks.ts
+function useDubhe() {
+  return useDubheFromProvider();
+}
+function useDubheContract() {
+  return useDubheContractFromProvider();
+}
+function useDubheGraphQL() {
+  return useDubheGraphQLFromProvider();
+}
+function useDubheECS() {
+  return useDubheECSFromProvider();
+}
+var useContract = useDubhe;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG,
+  DubheProvider,
+  getConfigSummary,
+  mergeConfigurations,
+  useContract,
+  useDubhe,
+  useDubheConfig,
+  useDubheContract,
+  useDubheECS,
+  useDubheGraphQL,
+  validateConfig
+});
+//# sourceMappingURL=index.js.map

package/dist/sui/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sui/index.ts","../../src/sui/config.ts","../../src/sui/utils.ts","../../src/sui/provider.tsx","../../src/sui/hooks.ts"],"sourcesContent":["/**\n * @0xobelisk/react/sui - Modern Dubhe React Integration\n *\n * 🚀 Simple, powerful, type-safe Sui blockchain development experience\n *\n * Features:\n * - ⚡ Auto-initialization with environment variable support\n * - 🔧 Configuration-driven setup with smart defaults\n * - 🛡️ Complete type safety with strict TypeScript\n * - 📦 Direct instance access without connection state management\n * - 🎯 Intuitive API design following React best practices\n */\n\n// ============ Type Exports ============\nexport type { NetworkType, DubheConfig, DubheReturn, ContractReturn } from './types';\n\n// ============ Configuration Management ============\nexport { useDubheConfig, DEFAULT_CONFIG } from './config';\n\nexport { mergeConfigurations, validateConfig, getConfigSummary } from './utils';\n\n// ============ Provider Component ============\nexport { DubheProvider } from './provider';\n\n// ============ Modern React Hooks ============\nexport {\n  // Primary Hook - Provider pattern\n  useDubhe,\n\n  // Compatibility alias\n  useContract,\n\n  // Individual Instance Hooks - optimized for specific use cases\n  useDubheContract,\n  useDubheGraphQL,\n  useDubheECS\n} from './hooks';\n","/**\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, NetworkType } 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, NetworkType } 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${errors.length > 1 ? 's' : ''}):\\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 React, { 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  useDubheContext,\n  useDubheFromProvider,\n  useDubheContractFromProvider,\n  useDubheGraphQLFromProvider,\n  useDubheECSFromProvider\n} from './provider';\nimport type { DubheConfig, 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":["import_react"]}

package/dist/sui/index.mjs

@@ -0,0 +1,27 @@
+import {
+  DEFAULT_CONFIG,
+  DubheProvider,
+  getConfigSummary,
+  mergeConfigurations,
+  useContract,
+  useDubhe,
+  useDubheConfig,
+  useDubheContract,
+  useDubheECS,
+  useDubheGraphQL,
+  validateConfig
+} from "../chunk-XI35QBSQ.mjs";
+export {
+  DEFAULT_CONFIG,
+  DubheProvider,
+  getConfigSummary,
+  mergeConfigurations,
+  useContract,
+  useDubhe,
+  useDubheConfig,
+  useDubheContract,
+  useDubheECS,
+  useDubheGraphQL,
+  validateConfig
+};
+//# sourceMappingURL=index.mjs.map

package/dist/sui/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/sui/provider.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Dubhe Provider - useRef Pattern for Client Management
+ *
+ * Features:
+ * - 🎯 Single client instances across application lifecycle
+ * - ⚡ useRef-based storage (no re-initialization on re-renders)
+ * - 🔧 Provider pattern for dependency injection
+ * - 🛡️ Complete type safety with strict TypeScript
+ * - 📦 Context-based client sharing
+ */
+import { ReactNode } from 'react';
+import { Dubhe } from '@0xobelisk/sui-client';
+import type { DubheConfig, DubheReturn } from './types';
+/**
+ * Context interface for Dubhe client instances
+ * All clients are stored using useRef to ensure single initialization
+ */
+interface DubheContextValue {
+    getContract: () => Dubhe;
+    getGraphqlClient: () => any | null;
+    getEcsWorld: () => any | null;
+    getAddress: () => string;
+    getMetrics: () => {
+        initTime: number;
+        requestCount: number;
+        lastActivity: number;
+    };
+    config: DubheConfig;
+}
+/**
+ * Props interface for DubheProvider component
+ */
+interface DubheProviderProps {
+    /** Configuration for Dubhe initialization */
+    config: Partial<DubheConfig>;
+    /** Child components that will have access to Dubhe clients */
+    children: ReactNode;
+}
+/**
+ * DubheProvider Component - useRef Pattern Implementation
+ *
+ * This Provider uses useRef to store client instances, ensuring they are:
+ * 1. Created only once during component lifecycle
+ * 2. Persisted across re-renders without re-initialization
+ * 3. Shared efficiently via React Context
+ *
+ * Key advantages over useMemo:
+ * - useRef guarantees single initialization (useMemo can re-run on dependency changes)
+ * - No dependency array needed (eliminates potential re-initialization bugs)
+ * - Better performance for heavy client objects
+ * - Clearer separation of concerns via Provider pattern
+ *
+ * @param props - Provider props containing config and children
+ * @returns Provider component wrapping children with Dubhe context
+ *
+ * @example
+ * ```typescript
+ * // App root setup
+ * function App() {
+ *   const dubheConfig = {
+ *     network: 'devnet',
+ *     packageId: '0x123...',
+ *     metadata: contractMetadata,
+ *     credentials: {
+ *       secretKey: process.env.NEXT_PUBLIC_PRIVATE_KEY
+ *     }
+ *   };
+ *
+ *   return (
+ *     <DubheProvider config={dubheConfig}>
+ *       <MyApplication />
+ *     </DubheProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function DubheProvider({ config, children }: DubheProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Custom hook to access Dubhe context
+ * Provides type-safe access to all Dubhe client instances
+ *
+ * @returns DubheContextValue with all client getters and config
+ * @throws Error if used outside of DubheProvider
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const dubheContext = useDubheContext();
+ *
+ *   const contract = dubheContext.getContract();
+ *   const graphqlClient = dubheContext.getGraphqlClient();
+ *   const ecsWorld = dubheContext.getEcsWorld();
+ *   const address = dubheContext.getAddress();
+ *
+ *   return <div>Connected as {address}</div>;
+ * }
+ * ```
+ */
+export declare function useDubheContext(): DubheContextValue;
+/**
+ * Enhanced hook that mimics the original useDubhe API
+ * Uses the Provider pattern internally but maintains backward compatibility
+ *
+ * @returns DubheReturn object with all instances and metadata
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { contract, graphqlClient, ecsWorld, address } = useDubheFromProvider();
+ *
+ *   const handleTransaction = async () => {
+ *     const tx = new Transaction();
+ *     await contract.tx.my_system.my_method({ tx });
+ *   };
+ *
+ *   return <button onClick={handleTransaction}>Execute</button>;
+ * }
+ * ```
+ */
+export declare function useDubheFromProvider(): DubheReturn;
+/**
+ * Individual client hooks for components that only need specific instances
+ * These are more efficient than useDubheFromProvider for single-client usage
+ */
+/**
+ * Hook for accessing only the Dubhe contract instance
+ */
+export declare function useDubheContractFromProvider(): Dubhe;
+/**
+ * Hook for accessing only the GraphQL client instance
+ */
+export declare function useDubheGraphQLFromProvider(): any | null;
+/**
+ * Hook for accessing only the ECS World instance
+ */
+export declare function useDubheECSFromProvider(): any | null;
+export {};