@evefrontier/dapp-kit 0.1.0

package/providers/SmartObjectProvider.tsx

@@ -0,0 +1,282 @@
+import {
+  ReactNode,
+  useState,
+  createContext,
+  useEffect,
+  useCallback,
+  useRef,
+} from "react";
+
+import {
+  Assemblies,
+  AssemblyType,
+  QueryParams,
+  DetailedSmartCharacterResponse,
+} from "../types";
+
+import { POLLING_INTERVAL } from "../utils/constants";
+import { getAssemblyWithOwner, MoveObjectData } from "../graphql";
+import {
+  getObjectId,
+  transformToAssembly,
+  transformToCharacter,
+} from "../utils";
+import { getDatahubGameInfo } from "../utils/datahub";
+import { useConnection } from "../hooks/useConnection";
+
+/** @category Types */
+export interface SmartObjectContextType {
+  assembly: AssemblyType<Assemblies> | null;
+  character: DetailedSmartCharacterResponse | null;
+  selectedObjectId: string;
+  loading: boolean;
+  error: string | null;
+  setSelectedObjectId: (id: string) => void;
+  refetch: () => Promise<void>;
+}
+
+/** @category Providers */
+export const SmartObjectContext = createContext<SmartObjectContextType>({
+  assembly: null,
+  character: null,
+  selectedObjectId: "",
+  loading: true,
+  error: null,
+  setSelectedObjectId: () => {},
+  refetch: async () => {},
+});
+
+/**
+ * SmartObjectProvider component provides context for smart objects data.
+ * It uses GraphQL queries to fetch objects on the Sui blockchain
+ * from the EVE Frontier package, with optional polling for updates.
+ *
+ * The provider fetches both the assembly data and its owner (character) information:
+ * 1. Fetches assembly data with dynamic fields
+ * 2. Uses owner_cap_id to resolve the Character OwnerCap
+ * 3. Fetches full character data from the Character ID
+ *
+ * @category Providers
+ */
+const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
+  const [assembly, setAssembly] = useState<AssemblyType<Assemblies> | null>(
+    null,
+  );
+  const [character, setCharacter] =
+    useState<DetailedSmartCharacterResponse | null>(null);
+  const [selectedObjectId, setSelectedObjectId] = useState<string>("");
+  const [selectedTenant, setSelectedTenant] = useState<string>("");
+  const [loading, setLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const pollingRef = useRef<NodeJS.Timeout | null>(null);
+  const lastDataHashRef = useRef<string | null>(null);
+
+  const { isConnected } = useConnection();
+
+  // Fetch object data with owner/character info
+  const fetchObjectData = useCallback(
+    async (itemId: string, selectedTenant: string, isInitialFetch = false) => {
+      if (!itemId || !selectedTenant) return;
+
+      if (isInitialFetch) {
+        setLoading(true);
+      }
+      setError(null);
+
+      try {
+        console.log(
+          "[DappKit] SmartObjectProvider: Fetching object with item ID and tenant:",
+          itemId,
+          selectedTenant,
+        );
+
+        const objectId = await getObjectId(itemId, selectedTenant);
+
+        // Fetch both assembly and character data
+        const { moveObject, character: characterInfo } =
+          await getAssemblyWithOwner(objectId);
+
+        if (!moveObject) {
+          console.warn(
+            "[DappKit] SmartObjectProvider: Object not found or not a Move object",
+          );
+          setAssembly(null);
+          setCharacter(null);
+          setError("Object not found or not a Move object");
+          return;
+        }
+
+        // Create a hash of the data to check for changes
+        const dataHash = JSON.stringify({
+          moveObject,
+          character: characterInfo,
+        });
+
+        // Only update state if the data changed (optimization for polling)
+        if (isInitialFetch || lastDataHashRef.current !== dataHash) {
+          console.log("[DappKit] SmartObjectProvider: Object data updated");
+          lastDataHashRef.current = dataHash;
+
+          // Extract typeId from the raw JSON to fetch datahub info
+          const rawJson = moveObject.contents?.json as
+            | { type_id?: string; status?: { type_id?: string } }
+            | undefined;
+          const typeId = rawJson?.type_id || rawJson?.status?.type_id || "0";
+
+          // Fetch datahub game info (name, description, image defaults)
+          let datahubInfo = null;
+          try {
+            datahubInfo = await getDatahubGameInfo(parseInt(typeId, 10));
+          } catch (err) {
+            console.warn(
+              "[DappKit] SmartObjectProvider: Failed to fetch datahub info:",
+              err,
+            );
+          }
+
+          // Transform assembly with character and datahub info
+          const transformed = await transformToAssembly(
+            objectId,
+            moveObject as MoveObjectData,
+            {
+              character: characterInfo,
+              datahubInfo,
+            },
+          );
+
+          setAssembly(transformed);
+
+          // Transform and set character
+          if (characterInfo) {
+            const transformedCharacter = transformToCharacter(characterInfo);
+            setCharacter(transformedCharacter);
+          } else {
+            setCharacter(null);
+          }
+        }
+        setError(null);
+      } catch (err: unknown) {
+        console.error("[DappKit] SmartObjectProvider: Query error:", err);
+        setError(err instanceof Error ? err.message : "Failed to fetch object");
+      } finally {
+        if (isInitialFetch) {
+          setLoading(false);
+        }
+      }
+    },
+    [],
+  );
+
+  // Initialize the object ID from env or query params
+  useEffect(() => {
+    console.log("[DappKit] SmartObjectProvider: Checking for item ID");
+
+    // Check if an object ID exists in the .env file
+    const envItemId = import.meta.env.VITE_ITEM_ID;
+    const envTenant = import.meta.env.VITE_EVE_WORLD_TENANT;
+
+    if (envItemId) {
+      console.log(
+        "[DappKit] SmartObjectProvider: Using item ID from env:",
+        envItemId,
+      );
+      setSelectedObjectId(envItemId);
+
+      if (envTenant) {
+        console.log(
+          "[DappKit] SmartObjectProvider: Using tenant from env:",
+          envTenant,
+        );
+        setSelectedTenant(envTenant);
+      } else {
+        console.error(
+          "[DappKit] SmartObjectProvider: VITE_ITEM_ID is set but VITE_EVE_WORLD_TENANT is missing. " +
+            "Both are required when using env-based configuration.",
+        );
+        setLoading(false);
+      }
+      return;
+    }
+
+    // Check if an object ID has been passed via query param
+    const queryParams = new URLSearchParams(window.location.search);
+    const queryItemId = queryParams.get(QueryParams.ITEM_ID);
+    const queryTenant = queryParams.get(QueryParams.TENANT);
+
+    if (queryItemId) {
+      setSelectedObjectId(queryItemId);
+    } else {
+      console.error("[DappKit] SmartObjectProvider: No object ID provided");
+      setLoading(false);
+    }
+
+    if (queryTenant) {
+      setSelectedTenant(queryTenant);
+    } else {
+      console.error("[DappKit] SmartObjectProvider: No tenant provided");
+    }
+  }, []);
+
+  // Fetch and poll for object data
+  useEffect(() => {
+    if (!selectedObjectId || !isConnected) {
+      if (!selectedObjectId) {
+        setLoading(false);
+      }
+      return;
+    }
+
+    // Initial fetch
+    fetchObjectData(selectedObjectId, selectedTenant, true);
+
+    // Set up polling
+    pollingRef.current = setInterval(() => {
+      fetchObjectData(selectedObjectId, selectedTenant, false);
+    }, POLLING_INTERVAL);
+
+    console.log(
+      "[DappKit] SmartObjectProvider: Started polling for object:",
+      selectedObjectId,
+    );
+
+    return () => {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current);
+        pollingRef.current = null;
+        console.log("[DappKit] SmartObjectProvider: Stopped polling");
+      }
+      lastDataHashRef.current = null;
+    };
+  }, [selectedObjectId, isConnected, fetchObjectData]);
+
+  const handleSetSelectedObjectId = useCallback((id: string) => {
+    console.log("[DappKit] SmartObjectProvider: Setting new object ID:", id);
+    lastDataHashRef.current = null;
+    setSelectedObjectId(id);
+  }, []);
+
+  const handleRefetch = useCallback(async () => {
+    if (selectedObjectId) {
+      await fetchObjectData(selectedObjectId, selectedTenant, true);
+    }
+  }, [selectedObjectId, selectedTenant, fetchObjectData]);
+
+  return (
+    <SmartObjectContext.Provider
+      value={{
+        assembly,
+        character,
+        selectedObjectId,
+        loading,
+        error,
+        setSelectedObjectId: handleSetSelectedObjectId,
+        refetch: handleRefetch,
+      }}
+    >
+      {children}
+    </SmartObjectContext.Provider>
+  );
+};
+
+export default SmartObjectProvider;

package/providers/VaultProvider.tsx

@@ -0,0 +1,114 @@
+import { ReactNode, useRef, useEffect, createContext } from "react";
+import {
+  useCurrentAccount,
+  useWallets,
+  useDAppKit,
+} from "@mysten/dapp-kit-react";
+import type { WalletAccount } from "@mysten/wallet-standard";
+import { STORAGE_KEYS } from "../utils/constants";
+
+/** @category Types */
+export interface VaultContextType {
+  currentAccount: WalletAccount | null;
+  walletAddress: string | undefined;
+  hasEveVault: boolean;
+  isConnected: boolean;
+  handleConnect: () => void;
+  handleDisconnect: () => void;
+}
+
+/** @category Providers */
+export const VaultContext = createContext<VaultContextType>({
+  currentAccount: null,
+  walletAddress: undefined,
+  hasEveVault: false,
+  isConnected: false,
+  handleConnect: () => {},
+  handleDisconnect: () => {},
+});
+
+/**
+ * VaultProvider component provides a context for managing Sui wallet connections.
+ * It uses @mysten/dapp-kit-react hooks for wallet management.
+ */
+// Module-level flag to prevent auto-connect from running multiple times
+// (persists across component remounts caused by wallet state changes)
+let globalAutoConnectAttempted = false;
+
+/** @category Providers */
+const VaultProvider = ({ children }: { children: ReactNode }) => {
+  // Sui dapp-kit hooks
+  const currentAccount = useCurrentAccount();
+  const dAppKit = useDAppKit();
+  const { connectWallet, disconnectWallet } = dAppKit;
+  const wallets = useWallets();
+
+  // Find Eve Vault wallet if available
+  const eveVaultWallet = wallets.find((wallet) =>
+    wallet.name.includes("Eve Vault"),
+  );
+
+  // Track if auto-connect has been attempted to prevent infinite loops
+  const hasAttemptedAutoConnect = useRef(false);
+
+  const handleConnect = () => {
+    const walletToConnect = eveVaultWallet || wallets[0];
+
+    if (!walletToConnect) {
+      console.warn("No wallet available to connect");
+      return;
+    }
+
+    try {
+      connectWallet({ wallet: walletToConnect });
+      console.log("[DappKit] Connected to wallet:", walletToConnect.name);
+      localStorage.setItem(STORAGE_KEYS.CONNECTED, "true");
+    } catch (error) {
+      console.error("[DappKit] Failed to connect wallet:", error);
+    }
+  };
+
+  const handleDisconnect = () => {
+    disconnectWallet();
+    localStorage.removeItem(STORAGE_KEYS.CONNECTED);
+    console.log("[DappKit] Wallet disconnected");
+  };
+
+  // Auto-reconnect if user was previously connected (only once)
+  useEffect(() => {
+    // Use both local ref AND global flag for maximum protection against re-render loops
+    if (hasAttemptedAutoConnect.current || globalAutoConnectAttempted) return;
+
+    const isPreviouslyConnected =
+      localStorage.getItem(STORAGE_KEYS.CONNECTED) === "true";
+
+    if (
+      typeof window !== "undefined" &&
+      isPreviouslyConnected &&
+      eveVaultWallet
+    ) {
+      hasAttemptedAutoConnect.current = true;
+      globalAutoConnectAttempted = true;
+      handleConnect();
+    }
+  }, [eveVaultWallet, handleConnect]);
+
+  const isConnected = !!currentAccount;
+
+  return (
+    <VaultContext.Provider
+      value={{
+        walletAddress: currentAccount?.address,
+        currentAccount,
+        hasEveVault: !!eveVaultWallet,
+        isConnected,
+        handleConnect,
+        handleDisconnect,
+      }}
+    >
+      {children}
+    </VaultContext.Provider>
+  );
+};
+
+export default VaultProvider;

package/providers/index.ts

@@ -0,0 +1,17 @@
+export { default as EveFrontierProvider } from "./EveFrontierProvider";
+export {
+  default as VaultProvider,
+  VaultContext,
+  type VaultContextType,
+} from "./VaultProvider";
+export {
+  default as SmartObjectProvider,
+  SmartObjectContext,
+  type SmartObjectContextType,
+} from "./SmartObjectProvider";
+export {
+  default as NotificationProvider,
+  NotificationContext,
+  type NotificationContextType,
+  type NotificationState,
+} from "./NotificationProvider";

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["./**/*.ts", "./**/*.tsx", "./vite-env.d.ts"],
+  "exclude": ["node_modules"]
+}
+

package/typedoc.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": [
+    "./index.ts"
+  ],
+  "entryPointStrategy": "expand",
+  "out": "./docs/api",
+  "name": "@evefrontier/dapp-kit",
+  "readme": "./README.md",
+  "includeVersion": true,
+  "excludePrivate": true,
+  "excludeProtected": true,
+  "excludeInternal": true,
+  "excludeExternals": true,
+  "categoryOrder": [
+    "Providers",
+    "Hooks",
+    "GraphQL",
+    "Types",
+    "Utilities",
+    "Wallet",
+    "Config",
+    "*"
+  ],
+  "navigation": {
+    "includeCategories": true,
+    "includeGroups": true
+  },
+  "sort": [
+    "source-order"
+  ],
+  "visibilityFilters": {
+    "protected": false,
+    "private": false,
+    "inherited": true,
+    "external": false
+  }
+}

package/types/global.d.ts

@@ -0,0 +1,7 @@
+import { dAppKit } from "../config/dapp-kit";
+
+declare module "@mysten/dapp-kit-react" {
+  interface Register {
+    dAppKit: typeof dAppKit;
+  }
+}

package/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./worldApiReturnTypes";
+export * from "./sponsoredTransaction";
+

package/types/sponsoredTransaction.ts

@@ -0,0 +1,26 @@
+import {
+  SponsoredTransactionArgs,
+  SponsoredTransactionOutput,
+} from "../wallet";
+
+/**
+ * Available sponsored transaction actions
+ *
+ * @category Types
+ */
+export enum SponsoredTransactionActions {
+  BRING_ONLINE = "online",
+  BRING_OFFLINE = "offline",
+  EDIT_UNIT = "edit-unit",
+  LINK_SMART_GATE = "link-smart-gate",
+  UNLINK_SMART_GATE = "unlink-smart-gate",
+}
+
+/** @category Types */
+export type SendSponsoredTransactionFn = (
+  input: SponsoredTransactionArgs,
+  options?: {
+    onSuccess?: (data: SponsoredTransactionOutput) => void;
+    onError?: (error: Error) => void;
+  },
+) => Promise<SponsoredTransactionOutput>;

package/types/types.ts

@@ -0,0 +1,113 @@
+import {
+  DetailedAssemblyResponse,
+  StorageModule,
+  TurretModule,
+  GateModule,
+  RefineryModule,
+  ManufacturingModule,
+  NetworkNodeModule,
+} from "./worldApiReturnTypes";
+
+// =========================================
+// Query Parameters
+// =========================================
+
+/** @category Types */
+export enum QueryParams {
+  ITEM_ID = "itemId",
+  TENANT = "tenant",
+}
+
+// =========================================
+// Assembly State and Actions
+// =========================================
+
+/** @category Types */
+export enum State {
+  NULL = "NULL",
+  UNANCHORED = "UNANCHORED",
+  ANCHORED = "anchored", // Anchored + offline
+  ONLINE = "online", // Anchored + online
+  DESTROYED = "destroyed",
+}
+
+/** @category Types */
+export enum ActionTypes {
+  UNANCHOR = "Unanchor",
+  ANCHOR = "Anchor",
+  BRING_ONLINE = "Online unit",
+  BRING_OFFLINE = "Offline unit",
+  DESTROY = "Destroy",
+}
+
+// =========================================
+// UI Related Types
+// =========================================
+
+/** @category Types */
+export enum Severity {
+  Error = "error",
+  Warning = "warning",
+  Info = "info",
+  Success = "success",
+}
+
+/** @category Types */
+export interface Notify {
+  type: Severity;
+  message: string;
+  name?: string;
+  namespace?: string;
+  namespaceLabel?: string;
+}
+
+// =========================================
+// Assembly Types
+// =========================================
+
+/** @category Types */
+export enum Assemblies {
+  SmartStorageUnit = "SmartStorageUnit",
+  SmartTurret = "SmartTurret",
+  SmartGate = "SmartGate",
+  NetworkNode = "NetworkNode",
+  Manufacturing = "Manufacturing",
+  Refinery = "Refinery",
+}
+
+/** @category Types */
+export interface AssemblyProperties<T extends Assemblies>
+  extends DetailedAssemblyResponse {
+  type: T;
+}
+
+/** @category Types */
+export type AssemblyType<T extends Assemblies> = {
+  [K in T]: K extends Assemblies.SmartStorageUnit
+    ? AssemblyProperties<K> & { storage: StorageModule }
+    : K extends Assemblies.SmartTurret
+    ? AssemblyProperties<K> & { turret: TurretModule }
+    : K extends Assemblies.SmartGate
+    ? AssemblyProperties<K> & { gate: GateModule }
+    : K extends Assemblies.NetworkNode
+    ? AssemblyProperties<K> & { networkNode: NetworkNodeModule }
+    : K extends Assemblies.Refinery
+    ? AssemblyProperties<K> & { refinery: RefineryModule }
+    : K extends Assemblies.Manufacturing
+    ? AssemblyProperties<K> & { manufacturing: ManufacturingModule }
+    : never;
+}[T];
+
+// =========================================
+// Character Related Types
+// =========================================
+
+/** @category Types */
+export interface DetailedSmartCharacterResponse {
+  address: string;
+  name: string;
+  id: string;
+  tribeId: number;
+  smartAssemblies: Assemblies[];
+  portrait: string;
+}