@evefrontier/dapp-kit 0.1.2 → 0.1.3

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

package/utils/__tests__/config.test.ts

@@ -0,0 +1,424 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const TEST_EVE_WORLD_PACKAGE_ID =
+  "0x2ff3e06b96eb830bdcffbc6cae9b8fe43f005c3b94cef05d9ec23057df16f107";
+
+vi.mock("../../graphql/client", () => ({
+  getSingletonConfigObjectByType: vi.fn(),
+}));
+
+import { getSingletonConfigObjectByType } from "../../graphql/client";
+import {
+  getEnergyConfig,
+  getEnergyUsageForType,
+  getFuelEfficiencyConfig,
+  getFuelEfficiencyForType,
+  resetConfigCachesForTesting,
+} from "../config";
+import { getEnergyConfigType, getFuelEfficiencyConfigType } from "../constants";
+
+/** Builds the response shape that config reads: data.objects.nodes[0].asMoveObject.contents.extract...dynamicFields.nodes */
+function mockConfigResponse(
+  nodes: Array<{ key: { json: string }; value: { json: string } }>,
+) {
+  return {
+    data: {
+      objects: {
+        nodes: [
+          {
+            address: "0xconfig",
+            asMoveObject: {
+              contents: {
+                extract: {
+                  extract: {
+                    asAddress: {
+                      addressAt: {
+                        dynamicFields: {
+                          pageInfo: { hasNextPage: false, endCursor: null },
+                          nodes,
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        ],
+      },
+    },
+  };
+}
+
+describe("config utilities", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubEnv("VITE_EVE_WORLD_PACKAGE_ID", TEST_EVE_WORLD_PACKAGE_ID);
+    resetConfigCachesForTesting();
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  // ============================================================================
+  // Parsing (via getEnergyConfig with mocked response)
+  // ============================================================================
+  describe("parsing", () => {
+    it("returns empty object when nodes is undefined (e.g. missing path)", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue({
+        data: {
+          objects: {
+            nodes: [
+              {
+                address: "0xcfg",
+                asMoveObject: {
+                  contents: {
+                    extract: {
+                      extract: {
+                        asAddress: {
+                          addressAt: {
+                            dynamicFields: { nodes: undefined },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      } as unknown as Awaited<
+        ReturnType<typeof getSingletonConfigObjectByType>
+      >);
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({});
+    });
+
+    it("returns empty object when nodes is empty array", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([]),
+      );
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({});
+    });
+
+    it("parses valid key/value nodes into typeId -> value map", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+          { key: { json: "88067" }, value: { json: "100" } },
+          { key: { json: "92279" }, value: { json: "10" } },
+        ]),
+      );
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({
+        77917: 500,
+        88067: 100,
+        92279: 10,
+      });
+    });
+
+    it("skips entries with invalid (non-numeric) key and continues parsing", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+          { key: { json: "not-a-number" }, value: { json: "99" } },
+          { key: { json: "88067" }, value: { json: "100" } },
+        ]),
+      );
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({
+        77917: 500,
+        88067: 100,
+      });
+    });
+
+    it("uses 0 for entries with invalid (non-numeric) value", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "nope" } },
+          { key: { json: "88067" }, value: { json: "100" } },
+        ]),
+      );
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({
+        77917: 0,
+        88067: 100,
+      });
+    });
+
+    it("does not silently zero out known type IDs when data is present", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+          { key: { json: "88071" }, value: { json: "300" } },
+        ]),
+      );
+
+      const config = await getEnergyConfig();
+      const usage77917 = await getEnergyUsageForType(77917);
+      const usage88071 = await getEnergyUsageForType(88071);
+      const usageMissing = await getEnergyUsageForType(99999);
+
+      expect(config[77917]).toBe(500);
+      expect(config[88071]).toBe(300);
+      expect(usage77917).toBe(500);
+      expect(usage88071).toBe(300);
+      expect(usageMissing).toBe(0);
+    });
+  });
+
+  // ============================================================================
+  // Caching
+  // ============================================================================
+  describe("caching", () => {
+    it("calls GraphQL once and returns same reference on second getEnergyConfig()", async () => {
+      const nodes = [{ key: { json: "77917" }, value: { json: "500" } }];
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse(nodes),
+      );
+
+      const first = await getEnergyConfig();
+      const second = await getEnergyConfig();
+
+      expect(getSingletonConfigObjectByType).toHaveBeenCalledTimes(1);
+      expect(getSingletonConfigObjectByType).toHaveBeenCalledWith(
+        getEnergyConfigType(),
+        "assembly_energy",
+      );
+      expect(first).toBe(second);
+      expect(second).toEqual({ 77917: 500 });
+    });
+
+    it("calls GraphQL once for getFuelEfficiencyConfig and returns same reference on second call", async () => {
+      const nodes = [{ key: { json: "12345" }, value: { json: "75" } }];
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue({
+        data: {
+          objects: {
+            nodes: [
+              {
+                address: "0xfuel",
+                asMoveObject: {
+                  contents: {
+                    extract: {
+                      extract: {
+                        asAddress: {
+                          addressAt: {
+                            dynamicFields: {
+                              pageInfo: { hasNextPage: false },
+                              nodes,
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      } as Awaited<ReturnType<typeof getSingletonConfigObjectByType>>);
+
+      const first = await getFuelEfficiencyConfig();
+      const second = await getFuelEfficiencyConfig();
+
+      expect(getSingletonConfigObjectByType).toHaveBeenCalledWith(
+        getFuelEfficiencyConfigType(),
+        "fuel_efficiency",
+      );
+      expect(first).toBe(second);
+      expect(second).toEqual({ 12345: 75 });
+    });
+  });
+
+  // ============================================================================
+  // Concurrent-call deduplication
+  // ============================================================================
+  describe("concurrent-call deduplication", () => {
+    it("performs a single fetch when getEnergyConfig() is invoked concurrently", async () => {
+      type MockResponse = Awaited<
+        ReturnType<typeof getSingletonConfigObjectByType>
+      >;
+      let resolveFetch: (v: MockResponse) => void;
+      const fetchPromise = new Promise<MockResponse>((r) => {
+        resolveFetch = r;
+      });
+      vi.mocked(getSingletonConfigObjectByType).mockReturnValue(fetchPromise);
+
+      const concurrentCalls = [
+        getEnergyConfig(),
+        getEnergyConfig(),
+        getEnergyConfig(),
+        getEnergyConfig(),
+        getEnergyConfig(),
+      ];
+
+      resolveFetch!(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+        ]),
+      );
+
+      const results = await Promise.all(concurrentCalls);
+
+      expect(getSingletonConfigObjectByType).toHaveBeenCalledTimes(1);
+      expect(results.every((r) => r === results[0])).toBe(true);
+      expect(results[0]).toEqual({ 77917: 500 });
+    });
+
+    it("performs a single fetch when getFuelEfficiencyConfig() is invoked concurrently", async () => {
+      type MockResponse = Awaited<
+        ReturnType<typeof getSingletonConfigObjectByType>
+      >;
+      let resolveFetch: (v: MockResponse) => void;
+      const fetchPromise = new Promise<MockResponse>((r) => {
+        resolveFetch = r;
+      });
+      vi.mocked(getSingletonConfigObjectByType).mockReturnValue(fetchPromise);
+
+      const concurrentCalls = [
+        getFuelEfficiencyConfig(),
+        getFuelEfficiencyConfig(),
+        getFuelEfficiencyConfig(),
+      ];
+
+      resolveFetch!(
+        mockConfigResponse([
+          { key: { json: "88071" }, value: { json: "200" } },
+        ]),
+      );
+
+      const results = await Promise.all(concurrentCalls);
+
+      expect(getSingletonConfigObjectByType).toHaveBeenCalledTimes(1);
+      expect(results.every((r) => r === results[0])).toBe(true);
+      expect(results[0]).toEqual({ 88071: 200 });
+    });
+  });
+
+  // ============================================================================
+  // Pagination / first-page behavior
+  // ============================================================================
+  describe("pagination behavior", () => {
+    it("parses first page of nodes and does not zero out returned entries", async () => {
+      // Simulates response where dynamicFields has one page of nodes (hasNextPage may be true on backend)
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+          { key: { json: "88067" }, value: { json: "100" } },
+        ]),
+      );
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({ 77917: 500, 88067: 100 });
+      expect(result[77917]).toBe(500);
+      expect(result[88067]).toBe(100);
+    });
+
+    it("returns empty object when first object has no nodes (missing path) without throwing", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue({
+        data: {
+          objects: {
+            nodes: [
+              {
+                address: "0xcfg",
+                asMoveObject: {
+                  contents: {
+                    extract: undefined,
+                  },
+                },
+              },
+            ],
+          },
+        },
+      } as unknown as Awaited<
+        ReturnType<typeof getSingletonConfigObjectByType>
+      >);
+
+      const result = await getEnergyConfig();
+
+      expect(result).toEqual({});
+    });
+  });
+
+  // ============================================================================
+  // getEnergyUsageForType / getFuelEfficiencyForType
+  // ============================================================================
+  describe("getEnergyUsageForType / getFuelEfficiencyForType", () => {
+    it("getEnergyUsageForType returns 0 for typeId not in config", async () => {
+      vi.mocked(getSingletonConfigObjectByType).mockResolvedValue(
+        mockConfigResponse([
+          { key: { json: "77917" }, value: { json: "500" } },
+        ]),
+      );
+
+      const missing = await getEnergyUsageForType(99999);
+
+      expect(missing).toBe(0);
+    });
+
+    it("getFuelEfficiencyForType returns cached value for typeId in config", async () => {
+      vi.mocked(getSingletonConfigObjectByType)
+        .mockResolvedValueOnce(
+          mockConfigResponse([
+            { key: { json: "77917" }, value: { json: "500" } },
+          ]),
+        )
+        .mockResolvedValueOnce({
+          data: {
+            objects: {
+              nodes: [
+                {
+                  address: "0xfuel",
+                  asMoveObject: {
+                    contents: {
+                      extract: {
+                        extract: {
+                          asAddress: {
+                            addressAt: {
+                              dynamicFields: {
+                                pageInfo: {
+                                  hasNextPage: false,
+                                  endCursor: null,
+                                },
+                                nodes: [
+                                  {
+                                    key: { json: "77917" },
+                                    value: { json: "75" },
+                                  },
+                                ],
+                              },
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              ],
+            },
+          },
+        });
+
+      const energy = await getEnergyUsageForType(77917);
+      const fuelEff = await getFuelEfficiencyForType(77917);
+
+      expect(energy).toBe(500);
+      expect(fuelEff).toBe(75);
+    });
+  });
+});

package/utils/__tests__/mapping.test.ts

@@ -95,9 +95,9 @@ describe("mapping utilities", () => {
       ).toBe(Assemblies.NetworkNode);
     });
 
-    it("returns SmartStorageUnit as default for unknown type", () => {
+    it("returns Assembly as default for unknown type", () => {
       expect(getAssemblyType("unknown::type::Unknown")).toBe(
-        Assemblies.SmartStorageUnit,
+        Assemblies.Assembly,
       );
     });
 

package/utils/burnRate.ts

@@ -0,0 +1,46 @@
+const MS_PER_HOUR = 3600000;
+
+/**
+ * Result of adjusting raw burn time for efficiency.
+ * - burnTimePerUnitMs: efficiency-adjusted milliseconds to burn one unit
+ * - unitsPerHour: how many units are burned per hour at this rate
+ */
+export interface AdjustedBurnRate {
+  burnTimePerUnitMs: number;
+  unitsPerHour: number;
+}
+
+/**
+ * Takes raw burn time (ms per unit at 100%) and efficiency (0–100 scale),
+ * returns efficiency-adjusted burn time per unit and units burned per hour.
+ * E.g. raw 3600000 ms, 90% efficient → burn time 3240000 ms, ~1.11 units/hour.
+ *
+ * @param rawBurnTimeMs - Milliseconds to burn one unit at 100% efficiency. If non-finite or negative, treated as 0 so both returned fields are finite and consistent.
+ * @param efficiencyPercent - Efficiency as percentage on a 0–100 scale (e.g. 90 for 90%). Values outside [0, 100] are treated as invalid; when null/undefined, not finite, ≤0, or >100, raw is used as-is for burn time.
+ * @returns { burnTimePerUnitMs, unitsPerHour }
+ * @category Utilities
+ */
+export function getAdjustedBurnRate(
+  rawBurnTimeMs: number,
+  efficiencyPercent: number | null | undefined,
+): AdjustedBurnRate {
+  const raw =
+    Number.isFinite(rawBurnTimeMs) && rawBurnTimeMs >= 0 ? rawBurnTimeMs : 0;
+
+  const validEfficiency =
+    efficiencyPercent != null &&
+    Number.isFinite(efficiencyPercent) &&
+    efficiencyPercent > 0 &&
+    efficiencyPercent <= 100;
+
+  const burnTimePerUnitMs = validEfficiency
+    ? raw * (efficiencyPercent / 100)
+    : raw;
+
+  const unitsPerHour =
+    burnTimePerUnitMs > 0 && Number.isFinite(burnTimePerUnitMs)
+      ? MS_PER_HOUR / burnTimePerUnitMs
+      : 0;
+
+  return { burnTimePerUnitMs, unitsPerHour };
+}