@evefrontier/dapp-kit 0.1.1 → 0.1.3

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);
+  });
+});

package/utils/__tests__/characterOwnedObjects.test.ts

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { GetCharacterAndOwnedObjectsResponse } from "../../graphql/types";
+import {
+  getCharacterOwnedObjectsJson,
+  getCharacterOwnedObjects,
+} from "../characterOwnedObjects";
+
+vi.mock("../../graphql/client", () => ({
+  getCharacterAndOwnedObjects: vi.fn(),
+}));
+
+import { getCharacterAndOwnedObjects } from "../../graphql/client";
+
+/** Minimal owned object node shape (Gate/Assembly/Character/NetworkNode). */
+function ownedObjectNode(json: Record<string, unknown>, typeRepr: string) {
+  return {
+    contents: {
+      extract: {
+        asAddress: {
+          asObject: {
+            asMoveObject: {
+              contents: { type: { repr: typeRepr }, json },
+            },
+          },
+        },
+      },
+    },
+  };
+}
+
+/** Builds a valid GetCharacterAndOwnedObjectsResponse with the given owned-object json payloads. */
+function buildResponse(
+  ownedJsons: Record<string, unknown>[],
+  typeRepr = "0x2::example::Object",
+): GetCharacterAndOwnedObjectsResponse {
+  const nodes = ownedJsons.map((json) => ownedObjectNode(json, typeRepr));
+  return {
+    address: {
+      address: "0xwallet",
+      objects: {
+        nodes: [
+          {
+            contents: {
+              extract: {
+                asAddress: {
+                  asObject: {
+                    asMoveObject: {
+                      contents: {
+                        type: { repr: "0x2::character::Character" },
+                        json: { id: "0xchar", metadata: {} },
+                      },
+                    },
+                  },
+                  objects: { nodes },
+                },
+              },
+            },
+          },
+        ],
+      },
+    },
+  };
+}
+
+describe("getCharacterOwnedObjectsJson", () => {
+  it("returns undefined when data is undefined", () => {
+    expect(getCharacterOwnedObjectsJson(undefined)).toBeUndefined();
+  });
+
+  it("returns undefined when data is null", () => {
+    expect(getCharacterOwnedObjectsJson(null as unknown as undefined)).toBeUndefined();
+  });
+
+  it("returns undefined when address is missing", () => {
+    expect(
+      getCharacterOwnedObjectsJson(
+        {} as unknown as GetCharacterAndOwnedObjectsResponse,
+      ),
+    ).toBeUndefined();
+  });
+
+  it("returns undefined when address.objects is missing", () => {
+    expect(
+      getCharacterOwnedObjectsJson({
+        address: { address: "0x" },
+      } as unknown as GetCharacterAndOwnedObjectsResponse),
+    ).toBeUndefined();
+  });
+
+  it("returns undefined when address.objects.nodes is missing", () => {
+    expect(
+      getCharacterOwnedObjectsJson({
+        address: { address: "0x", objects: {} },
+      } as unknown as GetCharacterAndOwnedObjectsResponse),
+    ).toBeUndefined();
+  });
+
+  it("returns undefined when address.objects.nodes is empty", () => {
+    expect(
+      getCharacterOwnedObjectsJson({
+        address: { address: "0x", objects: { nodes: [] } },
+      }),
+    ).toBeUndefined();
+  });
+
+  it("returns undefined when first node has no contents.extract.asAddress.objects", () => {
+    const data = {
+      address: {
+        address: "0x",
+        objects: {
+          nodes: [
+            {
+              contents: {
+                extract: {
+                  asAddress: {
+                    /* objects missing – path ends here */
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+    } as unknown as GetCharacterAndOwnedObjectsResponse;
+    expect(getCharacterOwnedObjectsJson(data)).toBeUndefined();
+  });
+
+  it("returns undefined when objects.nodes is empty", () => {
+    const data = buildResponse([]);
+    expect(getCharacterOwnedObjectsJson(data)).toBeUndefined();
+  });
+
+  it("extracts json array from full deep GraphQL shape (single object)", () => {
+    const json1 = { id: "0xobj1", type_id: "123", owner_cap_id: "0xcap" };
+    const data = buildResponse([json1]);
+    const result = getCharacterOwnedObjectsJson(data);
+    expect(result).toEqual([json1]);
+  });
+
+  it("extracts json array from full deep GraphQL shape (multiple objects)", () => {
+    const json1 = { id: "0xgate", type_id: "gate" };
+    const json2 = { id: "0xasm", type_id: "assembly", metadata: {} };
+    const json3 = { id: "0xchar", tribe_id: 17, character_address: "0xaddr" };
+    const data = buildResponse([json1, json2, json3]);
+    const result = getCharacterOwnedObjectsJson(data);
+    expect(result).toEqual([json1, json2, json3]);
+  });
+
+  it("preserves exact json payloads (regression: deep path must match GraphQL shape)", () => {
+    const nested = {
+      id: "0xnode",
+      fuel: { quantity: "100", is_burning: false },
+      connected_assembly_ids: ["0xa", "0xb"],
+    };
+    const data = buildResponse([nested]);
+    const result = getCharacterOwnedObjectsJson(data);
+    expect(result).toHaveLength(1);
+    expect(result![0]).toEqual(nested);
+  });
+});
+
+describe("getCharacterOwnedObjects", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns extracted json array when response has data with owned objects", async () => {
+    const payloads = [
+      { id: "0x1", type_id: "gate" },
+      { id: "0x2", type_id: "assembly" },
+    ];
+    const responseData = buildResponse(payloads);
+    vi.mocked(getCharacterAndOwnedObjects).mockResolvedValue({
+      data: responseData,
+    });
+
+    const result = await getCharacterOwnedObjects("0xwallet");
+
+    expect(getCharacterAndOwnedObjects).toHaveBeenCalledWith("0xwallet");
+    expect(result).toEqual(payloads);
+  });
+
+  it("returns undefined when response.data is undefined", async () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.mocked(getCharacterAndOwnedObjects).mockResolvedValue({});
+
+    const result = await getCharacterOwnedObjects("0xwallet");
+
+    expect(result).toBeUndefined();
+    expect(warnSpy).toHaveBeenCalledWith(
+      "[Dapp] No data returned from getCharacterAndOwnedObjects",
+    );
+    warnSpy.mockRestore();
+  });
+
+  it("returns undefined when response.data has no owned objects (empty nodes)", async () => {
+    const responseData = buildResponse([]);
+    vi.mocked(getCharacterAndOwnedObjects).mockResolvedValue({
+      data: responseData,
+    });
+
+    const result = await getCharacterOwnedObjects("0xwallet");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined when response.data.address is missing", async () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.mocked(getCharacterAndOwnedObjects).mockResolvedValue({
+      data: {} as GetCharacterAndOwnedObjectsResponse,
+    });
+
+    const result = await getCharacterOwnedObjects("0xwallet");
+
+    expect(result).toBeUndefined();
+    warnSpy.mockRestore();
+  });
+});