@evefrontier/dapp-kit 0.1.1 → 0.1.3

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

package/utils/character.ts

@@ -0,0 +1,46 @@
+import type { CharacterInfo, RawCharacterData } from "../graphql/types";
+
+function parseOptionalInt(value: unknown): number {
+  if (value == null) return 0;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const n = parseInt(value, 10);
+    return Number.isNaN(n) ? 0 : n;
+  }
+  return 0;
+}
+
+/**
+ * Normalize raw character JSON (from wallet/assembly GQL responses) into CharacterInfo.
+ * Accepts varying shapes; returns null when input is not a usable object.
+ *
+ * @param json - Raw JSON (e.g. from contents.json or extract...contents.json)
+ * @returns CharacterInfo or null
+ * @category Character Helpers
+ */
+export function parseCharacterFromJson(json: unknown): CharacterInfo | null {
+  if (json == null || typeof json !== "object" || Array.isArray(json)) {
+    return null;
+  }
+  const obj = json as Record<string, unknown>;
+  const metadata =
+    obj.metadata != null &&
+    typeof obj.metadata === "object" &&
+    !Array.isArray(obj.metadata)
+      ? (obj.metadata as Record<string, unknown>)
+      : undefined;
+  const key =
+    obj.key != null && typeof obj.key === "object" && !Array.isArray(obj.key)
+      ? (obj.key as Record<string, unknown>)
+      : undefined;
+
+  return {
+    id: typeof obj.id === "string" ? obj.id : "",
+    address:
+      typeof obj.character_address === "string" ? obj.character_address : "",
+    name: typeof metadata?.name === "string" ? metadata.name : "",
+    tribeId: parseOptionalInt(obj.tribe_id),
+    characterId: parseOptionalInt(key?.item_id),
+    _raw: json as RawCharacterData,
+  };
+}

package/utils/characterOwnedObjects.ts

@@ -0,0 +1,52 @@
+import { getCharacterAndOwnedObjects } from "../graphql/client";
+import type { GetCharacterAndOwnedObjectsResponse } from "../graphql/types";
+
+/**
+ * Extracts the JSON payloads from the first character's owned objects
+ * (from getCharacterAndOwnedObjects response data).
+ *
+ * @param data - Response data from getCharacterAndOwnedObjects
+ * @returns Array of contents.json for each owned object, or undefined if missing
+ *
+ * @category Character Helpers
+ */
+export function getCharacterOwnedObjectsJson(
+  data: GetCharacterAndOwnedObjectsResponse | undefined,
+): Record<string, unknown>[] | undefined {
+  const objects =
+    data?.address?.objects?.nodes?.[0]?.contents?.extract?.asAddress?.objects;
+  if (!objects?.nodes?.length) return undefined;
+  return objects.nodes.map(
+    (node) =>
+      node.contents.extract.asAddress.asObject.asMoveObject.contents.json,
+  );
+}
+
+/**
+ * Fetches the character and owned objects for an address, then returns the JSON
+ * payloads of the first character's owned objects.
+ *
+ * @param address - Wallet/signer address to query
+ * @returns Promise resolving to an array of contents.json per owned object, or undefined if none
+ *
+ * @category Character Helpers
+ */
+export async function getCharacterOwnedObjects(
+  address: string,
+): Promise<Record<string, unknown>[] | undefined> {
+  const response = await getCharacterAndOwnedObjects(address).then(
+    (response) => {
+      const data = response.data;
+      if (!data) {
+        console.warn(
+          "[Dapp] No data returned from getCharacterAndOwnedObjects",
+        );
+        return;
+      }
+      const ownedObjectsJson = getCharacterOwnedObjectsJson(data);
+      return ownedObjectsJson;
+    },
+  );
+
+  return response;
+}