@evefrontier/dapp-kit 0.1.2 → 0.1.5

package/providers/SmartObjectProvider.tsx

@@ -38,7 +38,7 @@ export type FetchObjectDataInput =
 /** @category Providers */
 export const SmartObjectContext = createContext<SmartObjectContextType>({
   assembly: null,
-  character: null,
+  assemblyOwner: null,
   loading: true,
   error: null,
   refetch: async () => {},
@@ -49,10 +49,10 @@ export const SmartObjectContext = createContext<SmartObjectContextType>({
  * 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:
+ * The provider fetches both the assembly data and its owner (assemblyOwner) 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
+ * 3. Fetches full assemblyOwner data from the Character ID
  *
  * @category Providers
  */
@@ -60,7 +60,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
   const [assembly, setAssembly] = useState<AssemblyType<Assemblies> | null>(
     null,
   );
-  const [character, setCharacter] =
+  const [assemblyOwner, setAssemblyOwner] =
     useState<DetailedSmartCharacterResponse | null>(null);
   const [selectedObjectId, setSelectedObjectId] = useState<string>("");
   const [selectedTenant, setSelectedTenant] = useState<string>("");
@@ -73,7 +73,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
 
   const { isConnected } = useConnection();
 
-  // Fetch object data with owner/character info.
+  // Fetch object data with owner/assemblyOwner info.
   // Accepts either { itemId, selectedTenant } (derive Sui object ID) or { objectId } (use directly).
   const fetchObjectData = useCallback(
     async (input: FetchObjectDataInput, isInitialFetch = false) => {
@@ -100,11 +100,12 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
             : { objectId },
         );
 
-        // Fetch both assembly and character data
+        // Fetch both assembly and assemblyOwner data
         const {
           moveObject,
-          character: characterInfo,
+          assemblyOwner: characterInfo,
           energySource,
+          destinationGate,
         } = await getAssemblyWithOwner(objectId);
 
         if (!moveObject) {
@@ -112,7 +113,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
             "[DappKit] SmartObjectProvider: Object not found or not a Move object",
           );
           setAssembly(null);
-          setCharacter(null);
+          setAssemblyOwner(null);
           setError("Object not found or not a Move object");
           return;
         }
@@ -120,7 +121,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
         // Create a hash of the data to check for changes
         const dataHash = JSON.stringify({
           moveObject,
-          character: characterInfo,
+          assemblyOwner: characterInfo,
           energySource,
         });
 
@@ -146,7 +147,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
             );
           }
 
-          // Transform assembly with character and datahub info
+          // Transform assembly with assemblyOwner and datahub info
           const transformed = await transformToAssembly(
             objectId,
             moveObject as MoveObjectData,
@@ -154,17 +155,18 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
               character: characterInfo,
               datahubInfo,
               energySource: energySource,
+              destinationGate: destinationGate,
             },
           );
 
           setAssembly(transformed);
 
-          // Transform and set character
+          // Transform and set assemblyOwner: owner of the assembly
           if (characterInfo) {
             const transformedCharacter = transformToCharacter(characterInfo);
-            setCharacter(transformedCharacter);
+            setAssemblyOwner(transformedCharacter);
           } else {
-            setCharacter(null);
+            setAssemblyOwner(null);
           }
         }
         setError(null);
@@ -219,9 +221,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
   // Fetch and poll for object data
   useEffect(() => {
     if (!selectedObjectId || !isConnected) {
-      if (!selectedObjectId) {
-        setLoading(false);
-      }
+      setLoading(false);
       return;
     }
 
@@ -270,7 +270,7 @@ const SmartObjectProvider = ({ children }: { children: ReactNode }) => {
     <SmartObjectContext.Provider
       value={{
         assembly,
-        character,
+        assemblyOwner,
         loading,
         error,
         refetch: handleRefetch,

package/types/contexts.ts

@@ -28,7 +28,7 @@ export enum SupportedWallets {
  * @category Types */
 export interface SmartObjectContextType {
   assembly: AssemblyType<Assemblies> | null;
-  character: DetailedSmartCharacterResponse | null;
+  assemblyOwner: DetailedSmartCharacterResponse | null;
   loading: boolean;
   error: string | null;
   refetch: () => Promise<void>;

package/types/sponsoredTransaction.ts

@@ -12,7 +12,9 @@ import { Assemblies } from "./types";
 export enum SponsoredTransactionActions {
   BRING_ONLINE = "online",
   BRING_OFFLINE = "offline",
+  /** @deprecated Use UPDATE_METADATA instead */
   EDIT_UNIT = "edit-unit",
+  UPDATE_METADATA = "update-metadata",
   LINK_SMART_GATE = "link-smart-gate",
   UNLINK_SMART_GATE = "unlink-smart-gate",
 }
@@ -54,8 +56,15 @@ export const ASSEMBLY_TYPE_API_STRING: Record<Assemblies, string> = {
   [Assemblies.NetworkNode]: "network-nodes",
   [Assemblies.Manufacturing]: "manufacturing",
   [Assemblies.Refinery]: "refineries",
+  [Assemblies.Assembly]: "assemblies",
 } as const;
 
 /** API slug for assembly type in sponsored transaction payloads (e.g. "storage-units"). */
 export type SponsoredTransactionAssemblyType =
   (typeof ASSEMBLY_TYPE_API_STRING)[Assemblies];
+
+export interface SponsoredTransactionMetadata {
+  name?: string;
+  description?: string;
+  url?: string;
+}

package/types/types.ts

@@ -73,6 +73,7 @@ export enum Assemblies {
   NetworkNode = "NetworkNode",
   Manufacturing = "Manufacturing",
   Refinery = "Refinery",
+  Assembly = "Assembly",
 }
 
 /** @category Types */
@@ -86,16 +87,18 @@ 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;
+      ? 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 }
+              : K extends Assemblies.Assembly
+                ? AssemblyProperties<K>
+                : never;
 }[T];
 
 // =========================================
@@ -111,3 +114,42 @@ export interface DetailedSmartCharacterResponse {
   smartAssemblies: Assemblies[];
   portrait: string;
 }
+
+// =========================================
+// Datahub Game Info
+// =========================================
+
+/**
+ * Game item/type information from the EVE Frontier Datahub API.
+ *
+ * Contains metadata about items, assemblies, and other game objects
+ * including display names, descriptions, icons, and physical properties.
+ *
+ * @category Types
+ */
+export interface DatahubGameInfo {
+  /** The type ID (matches on-chain type_id) */
+  id: number;
+  /** Display name of the item/type */
+  name: string;
+  /** Description text */
+  description: string;
+  /** Mass in kg */
+  mass: number;
+  /** Radius in meters */
+  radius: number;
+  /** Volume in cubic meters */
+  volume: number;
+  /** Portion size for stacking */
+  portionSize: number;
+  /** Category group name (e.g., "Structures") */
+  groupName: string;
+  /** Category group ID */
+  groupId: number;
+  /** Top-level category name */
+  categoryName: string;
+  /** Top-level category ID */
+  categoryId: number;
+  /** URL to the item's icon image */
+  iconUrl: string;
+}

package/types/worldApiReturnTypes.ts

@@ -1,4 +1,6 @@
-import { State, AssemblyType, Assemblies } from "./types";
+import { MoveObjectData, RawSuiObjectData } from "../graphql/types";
+import { TransformOptions } from "../utils";
+import { State, Assemblies, type DatahubGameInfo } from "./types";
 
 // =========================================
 // Inventory Related Types
@@ -36,30 +38,21 @@ export interface StorageModule {
     items: InventoryItem[];
   };
   ephemeralInventories: EphemeralInventory[];
-  isParentNodeOnline: boolean;
 }
 
 /** @category Types */
-export interface TurretModule {
-  isParentNodeOnline: boolean;
-}
+export interface TurretModule {}
 
 /** @category Types */
-export interface ManufacturingModule {
-  isParentNodeOnline: boolean;
-}
+export interface ManufacturingModule {}
 
 /** @category Types */
-export interface RefineryModule {
-  isParentNodeOnline: boolean;
-}
+export interface RefineryModule {}
 
 /** @category Types */
 export interface GateModule {
-  linked: boolean;
   destinationId: string | undefined;
-  inRange: AssemblyType<Assemblies.SmartGate>[];
-  isParentNodeOnline: boolean;
+  destinationGate: RawSuiObjectData | null;
 }
 
 /** @category Types */
@@ -78,7 +71,7 @@ export interface NetworkNodeModule {
 /** @category Types @internal */
 export interface FuelResponse {
   quantity: number;
-  burnRateInMs: number;
+  burnTimeInMs: number;
   burnStartTime: number;
   isBurning: boolean;
   lastUpdated: number;
@@ -131,38 +124,21 @@ export interface SmartAssemblyResponse {
   id: string;
   item_id: number;
   type: Assemblies;
-  typeDetails?: GameTypeResponse;
+  typeDetails?: DatahubGameInfo;
   name: string;
   state: State;
   character?: SmartCharacterResponse;
   solarSystem?: SolarSystem;
+  isParentNodeOnline?: boolean;
+  energySourceId?: string;
   energyUsage: number;
   typeId: number;
+  _raw?: MoveObjectData;
+  _options?: TransformOptions;
 }
 
 /** @category Types */
 export interface DetailedAssemblyResponse extends SmartAssemblyResponse {
-  location: {
-    x: number;
-    y: number;
-    z: number;
-  };
   description: string;
   dappURL: string;
 }
-
-/** @category Types */
-export interface GameTypeResponse {
-  categoryId: number;
-  categoryName: string;
-  description: string;
-  groupId: number;
-  groupName: string;
-  iconUrl: string;
-  id: number;
-  mass: number;
-  name: string;
-  portionSize: number;
-  radius: number;
-  volume: number;
-}

package/utils/__tests__/burnRate.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { getAdjustedBurnRate } from "../burnRate";
+
+describe("getAdjustedBurnRate", () => {
+  const MS_PER_HOUR = 3600000;
+
+  it("returns ~1.11 units/hour when raw is 1h and efficiency is 90%", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 90);
+    expect(result.burnTimePerUnitMs).toBe(3240000); // 3600000 * 0.9
+    expect(result.unitsPerHour).toBeCloseTo(1.111111, 4);
+  });
+
+  it("returns burnTimePerUnitMs = raw and 1 unit/hour when efficiency is 100% and raw is 1h", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 100);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("returns 2.5 units/hour when raw is 1h and efficiency is 40%", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 40);
+    expect(result.burnTimePerUnitMs).toBe(1440000); // 3600000 * 0.4
+    expect(result.unitsPerHour).toBe(2.5);
+  });
+
+  it("returns 1.25 units/hour when raw is 1h and efficiency is 80%", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 80);
+    expect(result.burnTimePerUnitMs).toBe(2880000); // 3600000 * 0.8
+    expect(result.unitsPerHour).toBe(1.25);
+  });
+
+  it("returns ~6.67 units/hour when raw is 1h and efficiency is 15%", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 15);
+    expect(result.burnTimePerUnitMs).toBe(540000); // 3600000 * 0.15
+    expect(result.unitsPerHour).toBeCloseTo(6.666667, 4);
+  });
+
+  it("returns 10 units/hour when raw is 1h and efficiency is 10%", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 10);
+    expect(result.burnTimePerUnitMs).toBe(360000); // 3600000 * 0.1
+    expect(result.unitsPerHour).toBe(10);
+  });
+
+  it("uses raw as burn time and derives unitsPerHour when efficiency is null", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, null);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("uses raw as burn time when efficiency is undefined", () => {
+    const raw = 1800000;
+    const result = getAdjustedBurnRate(raw, undefined);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(2);
+  });
+
+  it("uses raw as burn time when efficiency is 0", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 0);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("returns unitsPerHour 0 when raw is 0", () => {
+    const result = getAdjustedBurnRate(0, 90);
+    expect(result.burnTimePerUnitMs).toBe(0);
+    expect(result.unitsPerHour).toBe(0);
+  });
+
+  it("normalizes invalid raw (NaN) to 0 and returns (0, 0)", () => {
+    const result = getAdjustedBurnRate(Number.NaN, 90);
+    expect(result.burnTimePerUnitMs).toBe(0);
+    expect(result.unitsPerHour).toBe(0);
+  });
+
+  it("normalizes invalid raw (Infinity) to 0 and returns (0, 0)", () => {
+    const result = getAdjustedBurnRate(Number.POSITIVE_INFINITY, 90);
+    expect(result.burnTimePerUnitMs).toBe(0);
+    expect(result.unitsPerHour).toBe(0);
+  });
+
+  it("normalizes invalid raw (negative) to 0 and returns (0, 0)", () => {
+    const result = getAdjustedBurnRate(-1000, 90);
+    expect(result.burnTimePerUnitMs).toBe(0);
+    expect(result.unitsPerHour).toBe(0);
+  });
+
+  it("handles negative efficiency by using raw (fallback)", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, -10);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("handles NaN efficiency by using raw", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, Number.NaN);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("treats efficiency > 100 as invalid and uses raw (fallback)", () => {
+    const raw = MS_PER_HOUR;
+    const result = getAdjustedBurnRate(raw, 250);
+    expect(result.burnTimePerUnitMs).toBe(raw);
+    expect(result.unitsPerHour).toBe(1);
+  });
+
+  it("computes correct unitsPerHour for 10 units/hour (6 min per unit)", () => {
+    const sixMinutesMs = 6 * 60 * 1000;
+    const result = getAdjustedBurnRate(sixMinutesMs, 100);
+    expect(result.burnTimePerUnitMs).toBe(sixMinutesMs);
+    expect(result.unitsPerHour).toBe(10);
+  });
+});

package/utils/__tests__/character.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { parseCharacterFromJson } from "../character";
+
+describe("parseCharacterFromJson", () => {
+  const validCharacterJson = {
+    id: "0x65916b0c872aa5e29b0e9ec66a29fa18cd5f85b188d48914d4437d42abc4f800",
+    character_address: "0x82da5c79037b5cb544ed89725f61a577d17c55a14941ea992a8d18cc476893d7",
+    tribe_id: 17,
+    key: { item_id: "12345", tenant: "default" },
+    metadata: {
+      name: "Test Character",
+      description: "",
+      url: "",
+      assembly_id: "0xassembly",
+    },
+  };
+
+  it("returns null when json is null", () => {
+    expect(parseCharacterFromJson(null)).toBeNull();
+  });
+
+  it("returns null when json is undefined", () => {
+    expect(parseCharacterFromJson(undefined)).toBeNull();
+  });
+
+  it("returns null when json is a string", () => {
+    expect(parseCharacterFromJson("not an object")).toBeNull();
+  });
+
+  it("returns null when json is an array", () => {
+    expect(parseCharacterFromJson([])).toBeNull();
+  });
+
+  it("returns CharacterInfo with all fields when given valid object", () => {
+    const result = parseCharacterFromJson(validCharacterJson);
+    expect(result).not.toBeNull();
+    expect(result!.id).toBe(validCharacterJson.id);
+    expect(result!.address).toBe(validCharacterJson.character_address);
+    expect(result!.name).toBe(validCharacterJson.metadata.name);
+    expect(result!.tribeId).toBe(17);
+    expect(result!.characterId).toBe(12345);
+    expect(result!._raw).toBe(validCharacterJson);
+  });
+
+  it("parses tribe_id when it is a string", () => {
+    const result = parseCharacterFromJson({
+      ...validCharacterJson,
+      tribe_id: "42",
+    });
+    expect(result).not.toBeNull();
+    expect(result!.tribeId).toBe(42);
+  });
+
+  it("parses key.item_id when it is a string", () => {
+    const result = parseCharacterFromJson({
+      ...validCharacterJson,
+      key: { item_id: "999", tenant: "x" },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.characterId).toBe(999);
+  });
+
+  it("returns 0 for tribeId when tribe_id is missing", () => {
+    const { tribe_id: _, ...withoutTribe } = validCharacterJson;
+    const result = parseCharacterFromJson(withoutTribe);
+    expect(result).not.toBeNull();
+    expect(result!.tribeId).toBe(0);
+  });
+
+  it("returns 0 for characterId when key is missing", () => {
+    const { key: _, ...withoutKey } = validCharacterJson;
+    const result = parseCharacterFromJson(withoutKey);
+    expect(result).not.toBeNull();
+    expect(result!.characterId).toBe(0);
+  });
+
+  it("returns empty string for name when metadata is not an object", () => {
+    const result = parseCharacterFromJson({
+      ...validCharacterJson,
+      metadata: "invalid",
+    });
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe("");
+  });
+
+  it("returns empty string for name when metadata.name is missing", () => {
+    const result = parseCharacterFromJson({
+      ...validCharacterJson,
+      metadata: { description: "", url: "", assembly_id: "0x" },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe("");
+  });
+
+  it("returns empty strings for id and address when missing or wrong type", () => {
+    const result = parseCharacterFromJson({
+      tribe_id: 0,
+      key: {},
+      metadata: {},
+    });
+    expect(result).not.toBeNull();
+    expect(result!.id).toBe("");
+    expect(result!.address).toBe("");
+    expect(result!.name).toBe("");
+  });
+
+  it("stores original json as _raw", () => {
+    const input = { ...validCharacterJson };
+    const result = parseCharacterFromJson(input);
+    expect(result!._raw).toBe(input);
+  });
+});