@evefrontier/dapp-kit 0.1.2 → 0.1.5

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

package/utils/config.ts

@@ -0,0 +1,151 @@
+import { getSingletonConfigObjectByType } from "../graphql/client";
+import { getEnergyConfigType, getFuelEfficiencyConfigType } from "./constants";
+
+/**
+ * Cached energy config: type_id -> energy usage (e.g. energy_constant).
+ * Populated from the on-chain EnergyConfig singleton.
+ */
+let energyConfigCache: Record<number, number> | null = null;
+let fuelEfficiencyConfigCache: Record<number, number> | null = null;
+
+/** In-flight promise for energy config so concurrent callers share one fetch. */
+let energyConfigInFlight: Promise<Record<number, number>> | null = null;
+/** In-flight promise for fuel efficiency config so concurrent callers share one fetch. */
+let fuelEfficiencyConfigInFlight: Promise<Record<number, number>> | null = null;
+
+/**
+ * Resets in-memory and in-flight caches. Only for use in tests.
+ * @internal
+ */
+export function resetConfigCachesForTesting(): void {
+  energyConfigCache = null;
+  fuelEfficiencyConfigCache = null;
+  energyConfigInFlight = null;
+  fuelEfficiencyConfigInFlight = null;
+}
+
+/**
+ * Parses EnergyConfig or FuelConfig object JSON (contents + dynamic fields) into a map of typeId -> value (e.g. energy_constant or fuel_efficiency).
+ * Supports:
+ * - Dynamic fields where name is type_id (string/number) and contents.json has value
+ * - contents.json with a table/map of type_id -> value
+ */
+function parseConfig(
+  configJson: Record<string, unknown> | undefined,
+): Record<number, number> {
+  const byTypeId: Record<number, number> = {};
+  const nodes = configJson as unknown as
+    | Array<{ key: { json: string }; value: { json: string } }>
+    | undefined;
+  if (!Array.isArray(nodes) || !nodes.length) return byTypeId;
+  for (const node of nodes) {
+    const typeId = parseInt(node.key?.json ?? "", 10);
+    if (Number.isNaN(typeId)) continue;
+    const energy = parseInt(node.value?.json ?? "", 10);
+    byTypeId[typeId] = Number.isNaN(energy) ? 0 : energy;
+  }
+  return byTypeId;
+}
+
+/**
+ * Fetches the EnergyConfig singleton via GraphQL (using getEnergyConfigType), parses it,
+ * caches the result, and returns the map of type_id -> energy usage.
+ * Subsequent calls return the cached map.
+ *
+ * @category Utilities
+ */
+export async function getEnergyConfig(): Promise<Record<number, number>> {
+  if (energyConfigCache) {
+    return energyConfigCache;
+  }
+  if (energyConfigInFlight) {
+    return energyConfigInFlight;
+  }
+
+  energyConfigInFlight = (async () => {
+    const result = await getSingletonConfigObjectByType(
+      getEnergyConfigType(),
+      "assembly_energy",
+    );
+
+    const energyConfigJson = result.data?.objects?.nodes[0]?.asMoveObject
+      ?.contents?.extract?.extract?.asAddress?.addressAt?.dynamicFields
+      ?.nodes as Record<string, unknown> | undefined;
+
+    energyConfigCache = parseConfig(energyConfigJson);
+    return energyConfigCache;
+  })();
+
+  try {
+    return await energyConfigInFlight;
+  } finally {
+    energyConfigInFlight = null;
+  }
+}
+
+/**
+ * Fetches the Fuel Efficiency Config singleton via GraphQL (using getFuelEfficiencyConfigType), parses it,
+ * caches the result, and returns the map of type_id -> fuel efficiency.
+ * Subsequent calls return the cached map.
+ *
+ * @category Utilities
+ */
+export async function getFuelEfficiencyConfig(): Promise<
+  Record<number, number>
+> {
+  if (fuelEfficiencyConfigCache) {
+    return fuelEfficiencyConfigCache;
+  }
+  if (fuelEfficiencyConfigInFlight) {
+    return fuelEfficiencyConfigInFlight;
+  }
+
+  fuelEfficiencyConfigInFlight = (async () => {
+    const result = await getSingletonConfigObjectByType(
+      getFuelEfficiencyConfigType(),
+      "fuel_efficiency",
+    );
+
+    const fuelEfficiencyConfigJson = result.data?.objects?.nodes[0]
+      ?.asMoveObject?.contents?.extract?.extract?.asAddress?.addressAt
+      ?.dynamicFields?.nodes as Record<string, unknown> | undefined;
+
+    fuelEfficiencyConfigCache = parseConfig(fuelEfficiencyConfigJson);
+    return fuelEfficiencyConfigCache;
+  })();
+
+  try {
+    return await fuelEfficiencyConfigInFlight;
+  } finally {
+    fuelEfficiencyConfigInFlight = null;
+  }
+}
+
+/**
+ * Returns the energy usage for a given assembly type ID from the on-chain EnergyConfig.
+ * Uses cached EnergyConfig data after the first fetch.
+ *
+ * @param typeId - In-game type ID (e.g. from rawData.type_id)
+ * @returns Energy usage (e.g. energy_constant), or 0 if not found or not yet loaded
+ * @category Utilities
+ */
+export async function getEnergyUsageForType(typeId: number): Promise<number> {
+  const config = await getEnergyConfig();
+
+  return config[typeId] ?? 0;
+}
+
+/**
+ * Returns the fuel efficiency for a given assembly type ID from the on-chain Fuel Efficiency Config.
+ * Uses cached Fuel Efficiency Config data after the first fetch.
+ *
+ * @param typeId - In-game type ID (e.g. from rawData.type_id)
+ * @returns Fuel efficiency (e.g. fuel_efficiency), or 0 if not found or not yet loaded
+ * @category Utilities
+ */
+export async function getFuelEfficiencyForType(
+  typeId: number,
+): Promise<number> {
+  const config = await getFuelEfficiencyConfig();
+  return config[typeId] ?? 0;
+}

package/utils/constants.ts

@@ -50,6 +50,16 @@ export const getCharacterOwnerCapType = (): string => {
   return `${pkg}::access::OwnerCap<${pkg}::character::Character>`;
 };
 
+/**
+ * Get the Character PlayerProfile type string (derived from package ID).
+ * @returns The fully qualified type string for Character PlayerProfile
+ * @category Utilities
+ */
+export const getCharacterPlayerProfileType = (): string => {
+  const pkg = getEveWorldPackageId();
+  return `${pkg}::character::PlayerProfile`;
+};
+
 /**
  * Get the ObjectRegistry type string (derived from package ID).
  * @returns The fully qualified type string for ObjectRegistry
@@ -58,15 +68,37 @@ export const getCharacterOwnerCapType = (): string => {
 export const getObjectRegistryType = (): string =>
   `${getEveWorldPackageId()}::object_registry::ObjectRegistry`;
 
-/** Polling interval in milliseconds (10 seconds). @category Utilities */
+/**
+ * Get the EnergyConfig type string (derived from package ID).
+ * @returns The fully qualified type string for Energy Config
+ * @category Utilities
+ */
+export const getEnergyConfigType = (): string =>
+  `${getEveWorldPackageId()}::energy::EnergyConfig`;
+
+/**
+ * Get the Fuel Efficiency Config type string (derived from package ID).
+ * @returns The fully qualified type string for Fuel Efficiency Config
+ * @category Utilities
+ */
+export const getFuelEfficiencyConfigType = (): string =>
+  `${getEveWorldPackageId()}::fuel::FuelConfig`;
+
+/** Polling interval in milliseconds (10 seconds).
+ *  @category Constants
+ */
 export const POLLING_INTERVAL = 10000;
 
-/** Local storage keys. @category Utilities */
+/** Local storage keys.
+ *  @category Constants
+ */
 export const STORAGE_KEYS = {
   CONNECTED: "eve-dapp-connected",
 } as const;
 
-/** Type IDs for in-game items. @category Utilities */
+/** Type IDs for in-game items.
+ *  @category Constants
+ */
 /* eslint-disable @typescript-eslint/no-loss-of-precision */
 export enum TYPEIDS {
   LENS = 77518,
@@ -84,7 +116,7 @@ export enum TYPEIDS {
   REFUGE = 87160,
 }
 
-/** @category Utilities */
+/** @category Constants */
 export const EXCLUDED_TYPEIDS = [
   TYPEIDS.PORTABLE_REFINERY,
   TYPEIDS.PORTABLE_PRINTER,
@@ -92,5 +124,7 @@ export const EXCLUDED_TYPEIDS = [
   TYPEIDS.REFUGE,
 ];
 
-/** Volume - from wei units to m3. @category Utilities */
+/** Volume - from wei units to m3.
+ *  @category Constants
+ */
 export const ONE_M3 = 1000000000000000000;

package/utils/datahub.ts

@@ -1,42 +1,4 @@
-/**
- * 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;
-  /** Additional type-specific attributes */
-  attributes?: {
-    energyConstant?: number;
-    [key: string]: unknown;
-  };
-}
+import { DatahubGameInfo } from "../types";
 
 /**
  * Fetch game type information from the EVE Frontier Datahub API.
@@ -65,10 +27,10 @@ export interface DatahubGameInfo {
  * ```
  */
 export async function getDatahubGameInfo(
-  typeId: number
+  typeId: number,
 ): Promise<DatahubGameInfo> {
   const response = await fetch(
-    `https://world-api-stillness.live.tech.evefrontier.com/v2/types/${typeId}`
+    `https://world-api-stillness.live.tech.evefrontier.com/v2/types/${typeId}`,
   );
   const data = await response.json();
 

package/utils/errors.ts

@@ -137,7 +137,7 @@ ERRORS.CALLFROM_NOT_FOUND = ERRORS[2006];
 ERRORS.INSUFFICIENT_EVE = ERRORS[3002];
 ERRORS.LENS_UNAVAILABLE = ERRORS[5001];
 
-/** @category Utilities */
+/** @category Constants */
 export const ERROR_MESSAGES: Record<number, string> = Object.fromEntries(
   Object.entries(ERRORS)
     .filter(([key]) => /^\d+$/.test(key))

package/utils/index.ts

@@ -5,12 +5,21 @@ export {
   getObjectId,
   getRegistryAddress,
 } from "./mapping";
+export { getEnergyUsageForType, getFuelEfficiencyForType } from "./config";
+export {
+  getAdjustedBurnRate,
+  type AdjustedBurnRate,
+} from "./burnRate";
+export { parseCharacterFromJson } from "./character";
+export {
+  getCharacterOwnedObjectsJson,
+  getCharacterOwnedObjects,
+} from "./characterOwnedObjects";
 export { transformToAssembly, transformToCharacter } from "./transforms";
 export type { TransformOptions } from "./transforms";
 
 // Datahub utilities
 export { getDatahubGameInfo } from "./datahub";
-export type { DatahubGameInfo } from "./datahub";
 
 // General utilities
 export {

package/utils/mapping.ts

@@ -54,9 +54,12 @@ export function getAssemblyType(typeRepr: string): Assemblies {
   if (typeRepr.includes("::refinery::Refinery")) {
     return Assemblies.Refinery;
   }
+  if (typeRepr.includes("::assembly::Assembly")) {
+    return Assemblies.Assembly;
+  }
 
-  // Assembly type not found, return default SmartStorageUnit
-  return Assemblies.SmartStorageUnit;
+  // Assembly type not found, return default Assembly
+  return Assemblies.Assembly;
 }
 
 // Cache for the Registry address

package/utils/transforms.ts

@@ -5,6 +5,8 @@ import {
   DetailedSmartCharacterResponse,
   SmartAssemblyResponse,
   InventoryItem,
+  DatahubGameInfo,
+  DetailedAssemblyResponse,
 } from "../types";
 import type {
   MoveObjectData,
@@ -12,7 +14,8 @@ import type {
   CharacterInfo,
 } from "../graphql/types";
 import { getAssemblyType, parseStatus } from "./mapping";
-import { getDatahubGameInfo, type DatahubGameInfo } from "./datahub";
+import { getDatahubGameInfo } from "./datahub";
+import { getEnergyConfig, getEnergyUsageForType } from "./config";
 import { getObjectWithJson } from "../graphql";
 
 /**
@@ -43,6 +46,8 @@ export interface TransformOptions {
   datahubInfo?: DatahubGameInfo | null;
   /** Energy source information */
   energySource?: RawSuiObjectData | null;
+  /** Destination gate information, if Smart Gate */
+  destinationGate?: RawSuiObjectData | null;
 }
 
 /**
@@ -86,9 +91,10 @@ export async function transformToAssembly(
   // Build base assembly properties
   const state = parseStatus(rawData.status?.status?.["@variant"]);
 
-  // Use pre-fetched datahub info for defaults
+  // Use pre-fetched datahub info for defaults (name, description, image); energy from on-chain EnergyConfig
   const datahubInfo = options?.datahubInfo;
   const energySource = options?.energySource;
+  const energyUsage = await getEnergyUsageForType(parseInt(typeId, 10) || 0);
 
   const parentState = parseStatus(energySource?.status?.status?.["@variant"]);
 
@@ -99,22 +105,24 @@ export async function transformToAssembly(
     name: rawData.metadata?.name || "",
     description: rawData.metadata?.description || "",
     dappURL: rawData.metadata?.url || "",
-    energySourceId: energySource?.id || rawData.energy_source_id || "", // Parent network node ID
+    energySourceId:
+      assemblyType === Assemblies.NetworkNode
+        ? undefined
+        : energySource?.id || rawData.energy_source_id || "", // Parent network node ID
+    isParentNodeOnline:
+      assemblyType === Assemblies.NetworkNode
+        ? undefined
+        : parentState === State.ONLINE, // Defined in all cases except network nodes
     state,
     typeId: parseInt(typeId, 10) || 0,
-    energyUsage: 0,
-    location: {
-      x: 0,
-      y: 0,
-      z: 0,
-    },
+    energyUsage,
     typeDetails: datahubInfo,
     // Owner information
     character: options?.character || undefined,
     // Include raw data for debugging/extension
     _raw: moveObject,
     _options: options,
-  };
+  } as DetailedAssemblyResponse;
 
   // Add module-specific data based on assembly type
   switch (assemblyType) {
@@ -148,30 +156,26 @@ export async function transformToAssembly(
             items: inventoryItems,
           },
           ephemeralInventories: [],
-          isParentNodeOnline: parentState === State.ONLINE,
         },
       } as AssemblyType<Assemblies.SmartStorageUnit>;
 
     case Assemblies.SmartTurret:
       return {
         ...baseAssembly,
-        turret: {
-          isParentNodeOnline: parentState === State.ONLINE,
-        },
+        turret: {},
       } as AssemblyType<Assemblies.SmartTurret>;
 
     case Assemblies.SmartGate:
       return {
         ...baseAssembly,
         gate: {
-          linked: false,
           destinationId: rawData.linked_gate_id,
-          inRange: [],
-          isParentNodeOnline: parentState === State.ONLINE,
+          destinationGate: options?.destinationGate,
         },
       } as AssemblyType<Assemblies.SmartGate>;
 
     case Assemblies.NetworkNode:
+      const energyConfig = await getEnergyConfig();
       // TODO: Batch this call so that it can fetch all assemblies at once
       const linkedAssemblies: SmartAssemblyResponse[] = await Promise.all(
         (rawData.connected_assembly_ids || []).map(async (id) => {
@@ -184,12 +188,13 @@ export async function transformToAssembly(
             parseInt(assemblyJson?.type_id || "0", 10),
           );
 
+          const linkedTypeId = parseInt(assemblyJson?.type_id || "0", 10);
           return {
             id,
             item_id: parseInt(assemblyJson?.key?.item_id || "0", 10),
             state: parseStatus(assemblyJson?.status?.status?.["@variant"]),
-            energyUsage: 0,
-            typeId: parseInt(assemblyJson?.type_id || "0", 10),
+            energyUsage: energyConfig[linkedTypeId] ?? 0,
+            typeId: linkedTypeId,
             name: assemblyJson?.metadata?.name || "",
             type: getAssemblyType(assemblyJson?.type_id || ""),
             typeDetails: typeDetails,
@@ -201,7 +206,7 @@ export async function transformToAssembly(
         ...baseAssembly,
         networkNode: {
           fuel: {
-            burnRateInMs: parseInt(rawData.fuel?.burn_rate_in_ms || "0", 10),
+            burnTimeInMs: parseInt(rawData.fuel?.burn_rate_in_ms || "0", 10),
             burnStartTime: parseInt(rawData.fuel?.burn_start_time || "0", 10),
             isBurning: rawData.fuel?.is_burning || false,
             lastUpdated: parseInt(rawData.fuel?.last_updated || "0", 10),
@@ -247,18 +252,9 @@ export async function transformToAssembly(
       } as AssemblyType<Assemblies.Refinery>;
 
     default:
-      // Default to SmartStorageUnit
+      // Default to Assembly
       return {
         ...baseAssembly,
-        storage: {
-          mainInventory: {
-            capacity: "0",
-            usedCapacity: "0",
-            items: [],
-          },
-          ephemeralInventories: [],
-          isParentNodeOnline: state === State.ONLINE,
-        },
-      } as AssemblyType<Assemblies.SmartStorageUnit>;
+      } as AssemblyType<Assemblies.Assembly>;
   }
 }

package/wallet/features.ts

@@ -12,6 +12,7 @@ import {
   EVEFRONTIER_SPONSORED_TRANSACTION,
   SponsoredTransactionActions,
   SponsoredTransactionAssemblyType,
+  SponsoredTransactionMetadata,
 } from "../types";
 
 /**
@@ -30,7 +31,7 @@ export function getAssemblyTypeApiString(
  * Takes the transformed item_id and assembly type values of the assembly object
  * Normalization from assembly object to this flat shape is done in the hook by design;
  * callers may pass either the full assembly or pre-flattened values.
- * @category Wallet
+ * @category Types
  */
 export interface SponsoredTransactionInput {
   /** The transaction to be sponsored and executed */
@@ -40,8 +41,7 @@ export interface SponsoredTransactionInput {
   tenant: string;
   /** The assembly type to be sponsored and executed */
   assemblyType: SponsoredTransactionAssemblyType;
-  /** The Sui chain to execute on (e.g., "sui:testnet", "sui:mainnet") */
-  chain: `sui:${string}`;
+  metadata?: SponsoredTransactionMetadata;
 }
 
 /** Sponsored tx args with assembly object; id and assemblyType are derived. Tenant is optional; the hook resolves it from args, URL query param, or default. */
@@ -53,13 +53,13 @@ export type SponsoredTransactionArgs = Omit<
   account?: string;
   tenant?: string;
   txAction: SponsoredTransactionActions;
-  chain: `sui:${string}`;
+  metadata?: SponsoredTransactionMetadata;
 };
 
 /**
  * Output from a successful sponsored transaction
  *
- * @category Wallet
+ * @category Types
  */
 export interface SponsoredTransactionOutput {
   /** The transaction digest */

package/CHANGELOG.md

@@ -1,13 +0,0 @@
-# @evefrontier/dapp-kit
-
-## 0.1.2
-
-### Patch Changes
-
-- add .env sui object override to smart obj context
-
-## 0.1.1
-
-### Patch Changes
-
-- update supported wallets

package/docs/api/.nojekyll

@@ -1 +0,0 @@
-TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.

package/docs/api/assets/hierarchy.js

@@ -1 +0,0 @@
-window.hierarchyData = "eJyVkLEKwjAURf/lzqlSmzhkE/wA0VE6xPaVBtOk5MVBSv9dOigFFe3ytnPP4Q2IISSGPudSlgKRGkdVssEz9IBCTtebjqCxY6bu4u6HGHqKyRJD4Gp9Db1RW4FbdNCwPlFsTEW8fgdWbeocBCpnmKGRuM6mhexFYRTI5Vx76kxMz6kjcR880w/zR+YPuUDVWldH8tNHlCqnGqVmNXtKxjqqFwZ9w5Y2FbIcx/EBNsGWnQ=="