@gnosis-guild/enclave-react/dist/index.js

React hooks and utilities for Enclave SDK

// src/useEnclaveSDK.ts
import { useState, useEffect, useCallback, useRef } from "react";
import { useWalletClient, usePublicClient } from "wagmi";
import {
  EnclaveSDK,
  EnclaveEventType,
  RegistryEventType,
  SDKError
} from "@gnosis-guild/enclave-sdk";
var useEnclaveSDK = (config) => {
  const [sdk, setSdk] = useState(null);
  const [isInitialized, setIsInitialized] = useState(false);
  const [error, setError] = useState(null);
  const sdkRef = useRef(null);
  const publicClient = usePublicClient();
  const { data: walletClient } = useWalletClient();
  const initializeSDK = useCallback(async () => {
    try {
      setError(null);
      if (!publicClient) {
        throw new Error("Public client not available");
      }
      if (sdk) {
        sdk.cleanup();
      }
      const sdkConfig = {
        publicClient,
        walletClient,
        contracts: config.contracts || {
          enclave: "0x0000000000000000000000000000000000000000",
          ciphernodeRegistry: "0x0000000000000000000000000000000000000000"
        },
        chainId: config.chainId
      };
      const newSdk = new EnclaveSDK(sdkConfig);
      await newSdk.initialize();
      setSdk(newSdk);
      sdkRef.current = newSdk;
      setIsInitialized(true);
    } catch (err) {
      const errorMessage = err instanceof SDKError ? `SDK Error (${err.code}): ${err.message}` : `Failed to initialize SDK: ${err}`;
      setError(errorMessage);
      console.error("SDK initialization failed:", err);
    }
  }, [publicClient, walletClient, config.contracts, config.chainId]);
  useEffect(() => {
    if (config.autoConnect && publicClient && !isInitialized) {
      initializeSDK();
    }
  }, [config.autoConnect, publicClient, isInitialized, initializeSDK]);
  useEffect(() => {
    if (isInitialized && publicClient && walletClient) {
      initializeSDK();
    }
  }, [walletClient, initializeSDK]);
  useEffect(() => {
    return () => {
      if (sdkRef.current) {
        sdkRef.current.cleanup();
      }
    };
  }, []);
  const requestE3 = useCallback(
    (...args) => {
      if (!sdk) throw new Error("SDK not initialized");
      return sdk.requestE3(...args);
    },
    [sdk]
  );
  const activateE3 = useCallback(
    (...args) => {
      if (!sdk) throw new Error("SDK not initialized");
      return sdk.activateE3(...args);
    },
    [sdk]
  );
  const publishInput = useCallback(
    (...args) => {
      if (!sdk) throw new Error("SDK not initialized");
      return sdk.publishInput(...args);
    },
    [sdk]
  );
  const onEnclaveEvent = useCallback(
    (eventType, callback) => {
      if (!sdk) throw new Error("SDK not initialized");
      return sdk.onEnclaveEvent(eventType, callback);
    },
    [sdk]
  );
  const off = useCallback(
    (eventType, callback) => {
      if (!sdk) throw new Error("SDK not initialized");
      return sdk.off(eventType, callback);
    },
    [sdk]
  );
  return {
    sdk,
    isInitialized,
    error,
    requestE3,
    activateE3,
    publishInput,
    onEnclaveEvent,
    off,
    EnclaveEventType,
    RegistryEventType
  };
};

// src/index.ts
import { EnclaveEventType as EnclaveEventType2, RegistryEventType as RegistryEventType2 } from "@gnosis-guild/enclave-sdk";
export {
  EnclaveEventType2 as EnclaveEventType,
  RegistryEventType2 as RegistryEventType,
  useEnclaveSDK
};
//# sourceMappingURL=index.js.map