@shipload/sdk 1.0.0-next.15 → 1.0.0-next.17

package/src/managers/context.ts

@@ -8,6 +8,7 @@ import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
+import {NftManager} from './nft'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -16,6 +17,7 @@ export class GameContext {
     private _locations?: LocationsManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -63,6 +65,13 @@ export class GameContext {
         return this._actions
     }
 
+    get nft(): NftManager {
+        if (!this._nft) {
+            this._nft = new NftManager(this)
+        }
+        return this._nft
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/index.ts

@@ -7,3 +7,5 @@ export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
+export {NftManager} from './nft'
+export type {NftConfigForItem} from './nft'

package/src/managers/nft.ts

@@ -0,0 +1,28 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | null>()
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        this.cache.set(key, result)
+        return result ?? undefined
+    }
+}

package/src/nft/atomicassets.ts

@@ -1,10 +1,133 @@
-import {type APIClient, Name, type NameType, UInt64} from '@wharfkit/antelope'
+import {
+    ABI,
+    type ABIDef,
+    Action,
+    type APIClient,
+    type NameType,
+    Name,
+    PermissionLevel,
+    UInt64,
+} from '@wharfkit/antelope'
 import {deserializeAtomicData, type SchemaField} from './atomicdata'
 import {deserializeAsset, type NFTCargoItem, type NFTModuleSlot} from './deserializers'
+import type {ImmutableEntry} from './buildImmutableData'
+
+const PLACEHOLDER_AUTH = PermissionLevel.from({
+    actor: '............1',
+    permission: '............2',
+})
 
 export const ATOMICASSETS_ACCOUNT = 'atomicassets'
 export const SHIPLOAD_COLLECTION = 'shipload'
 
+const ATOMIC_ATTRIBUTE_VARIANT_NAME =
+    'variant_int8_int16_int32_int64_uint8_uint16_uint32_uint64_float32_float64_string_INT8_VEC_INT16_VEC_INT32_VEC_INT64_VEC_UINT8_VEC_UINT16_VEC_UINT32_VEC_UINT64_VEC_FLOAT_VEC_DOUBLE_VEC_STRING_VEC'
+
+const MINTASSET_ABI_DEF: ABIDef = {
+    version: 'eosio::abi/1.2',
+    types: [
+        {new_type_name: 'ATOMIC_ATTRIBUTE', type: ATOMIC_ATTRIBUTE_VARIANT_NAME},
+        {new_type_name: 'ATTRIBUTE_MAP', type: 'pair_string_ATOMIC_ATTRIBUTE[]'},
+        {new_type_name: 'INT8_VEC', type: 'bytes'},
+        {new_type_name: 'INT16_VEC', type: 'int16[]'},
+        {new_type_name: 'INT32_VEC', type: 'int32[]'},
+        {new_type_name: 'INT64_VEC', type: 'int64[]'},
+        {new_type_name: 'UINT8_VEC', type: 'bytes'},
+        {new_type_name: 'UINT16_VEC', type: 'uint16[]'},
+        {new_type_name: 'UINT32_VEC', type: 'uint32[]'},
+        {new_type_name: 'UINT64_VEC', type: 'uint64[]'},
+        {new_type_name: 'FLOAT_VEC', type: 'float32[]'},
+        {new_type_name: 'DOUBLE_VEC', type: 'float64[]'},
+        {new_type_name: 'STRING_VEC', type: 'string[]'},
+    ],
+    structs: [
+        {
+            name: 'pair_string_ATOMIC_ATTRIBUTE',
+            base: '',
+            fields: [
+                {name: 'first', type: 'string'},
+                {name: 'second', type: 'ATOMIC_ATTRIBUTE'},
+            ],
+        },
+        {
+            name: 'mintasset',
+            base: '',
+            fields: [
+                {name: 'authorized_minter', type: 'name'},
+                {name: 'collection_name', type: 'name'},
+                {name: 'schema_name', type: 'name'},
+                {name: 'template_id', type: 'int32'},
+                {name: 'new_asset_owner', type: 'name'},
+                {name: 'immutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'mutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'tokens_to_back', type: 'asset[]'},
+            ],
+        },
+    ],
+    actions: [{name: 'mintasset', type: 'mintasset', ricardian_contract: ''}],
+    variants: [
+        {
+            name: ATOMIC_ATTRIBUTE_VARIANT_NAME,
+            types: [
+                'int8',
+                'int16',
+                'int32',
+                'int64',
+                'uint8',
+                'uint16',
+                'uint32',
+                'uint64',
+                'float32',
+                'float64',
+                'string',
+                'INT8_VEC',
+                'INT16_VEC',
+                'INT32_VEC',
+                'INT64_VEC',
+                'UINT8_VEC',
+                'UINT16_VEC',
+                'UINT32_VEC',
+                'UINT64_VEC',
+                'FLOAT_VEC',
+                'DOUBLE_VEC',
+                'STRING_VEC',
+            ],
+        },
+    ],
+}
+
+export interface MintAssetParams {
+    authorizedMinter: NameType
+    collectionName: NameType
+    schemaName: NameType
+    templateId: number
+    newAssetOwner: NameType
+    immutableData: ImmutableEntry[]
+}
+
+const MINTASSET_ABI = ABI.from(MINTASSET_ABI_DEF)
+
+export function buildMintAssetAction(params: MintAssetParams): Action {
+    return Action.from(
+        {
+            account: Name.from(ATOMICASSETS_ACCOUNT),
+            name: Name.from('mintasset'),
+            authorization: [PLACEHOLDER_AUTH],
+            data: {
+                authorized_minter: Name.from(params.authorizedMinter),
+                collection_name: Name.from(params.collectionName),
+                schema_name: Name.from(params.schemaName),
+                template_id: params.templateId,
+                new_asset_owner: Name.from(params.newAssetOwner),
+                immutable_data: params.immutableData,
+                mutable_data: [],
+                tokens_to_back: [],
+            },
+        },
+        MINTASSET_ABI
+    )
+}
+
 export interface AtomicAssetRow {
     asset_id: string
     collection_name: string

package/src/nft/buildImmutableData.ts

@@ -0,0 +1,316 @@
+import {Serializer} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    MODULE_GENERATOR,
+    MODULE_HAULER,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+    MODULE_WARP,
+} from '../capabilities/modules'
+import {decodeStat, decodeCraftedItemStats} from '../derivation/crafting'
+import {getStatDefinitions} from '../derivation/stats'
+import type {ResourceCategory} from '../types'
+import {Types as ServerTypes} from '../contracts/server'
+import {
+    buildEntityDescription,
+    computeCrafterDrain,
+    computeCrafterSpeed,
+    computeEngineDrain,
+    computeEngineThrust,
+    computeGathererDepth,
+    computeGathererDrain,
+    computeGathererYield,
+    computeGeneratorCap,
+    computeGeneratorRech,
+    computeHaulerCapacity,
+    computeHaulerDrain,
+    computeHaulerEfficiency,
+    computeLoaderMass,
+    computeLoaderThrust,
+    computeWarpRange,
+} from './description'
+
+export type AtomicAttributeType =
+    | 'string'
+    | 'uint8'
+    | 'uint16'
+    | 'uint32'
+    | 'uint64'
+    | 'int32'
+    | 'image'
+    | 'ipfs'
+    | 'UINT16_VEC'
+    | 'UINT64_VEC'
+
+export interface ImmutableEntry {
+    first: string
+    second: [AtomicAttributeType, unknown]
+}
+
+export interface ImmutableModuleSlot {
+    type?: number | string | bigint
+    installed?: {item_id: number | string | bigint; stats: number | string | bigint}
+}
+
+export function moduleSlotsForImmutable(
+    modules: ServerTypes.module_entry[]
+): ImmutableModuleSlot[] {
+    return modules.map((m) => ({
+        type: Number(m.type.toString()),
+        installed: m.installed
+            ? {
+                  item_id: Number(m.installed.item_id.toString()),
+                  stats: BigInt(m.installed.stats.toString()),
+              }
+            : undefined,
+    }))
+}
+
+const IMAGE_HOST_URL = 'https://item.shiploadgame.com/item'
+
+function bytesToBase64Url(bytes: Uint8Array): string {
+    let binary = ''
+    for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]!)
+    const b64 = btoa(binary)
+    return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+export function computeNftImageUrl(
+    item: {item_id: number; stats: bigint; modules: ImmutableModuleSlot[]; quantity: number},
+    originX: number,
+    originY: number
+): string {
+    const payload = ServerTypes.nft_item_payload.from({
+        item: {
+            item_id: item.item_id,
+            stats: String(item.stats),
+            modules: item.modules,
+            quantity: item.quantity,
+        },
+        location: {x: String(originX), y: String(originY)},
+    })
+    const bytes = Serializer.encode({object: payload}).array
+    return `${IMAGE_HOST_URL}/${bytesToBase64Url(bytes)}.png`
+}
+
+function commonBaseImmutable(
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    img: string
+): ImmutableEntry[] {
+    return [
+        {first: 'quantity', second: ['uint32', quantity]},
+        {first: 'stats', second: ['uint64', String(stats)]},
+        {first: 'origin_x', second: ['int32', originX]},
+        {first: 'origin_y', second: ['int32', originY]},
+        {first: 'img', second: ['string', img]},
+    ]
+}
+
+export function buildResourceImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const item = getItem(itemId)
+    const cat = item.category
+    if (!cat) throw new Error(`Resource item ${itemId} has no category`)
+    const definitions = getStatDefinitions(cat as ResourceCategory)
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    base.push({first: definitions[0].key, second: ['uint16', decodeStat(stats, 0)]})
+    base.push({first: definitions[1].key, second: ['uint16', decodeStat(stats, 1)]})
+    base.push({first: definitions[2].key, second: ['uint16', decodeStat(stats, 2)]})
+    return base
+}
+
+export function buildComponentImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    const decoded = decodeCraftedItemStats(itemId, stats)
+    for (const [key, value] of Object.entries(decoded)) {
+        base.push({first: key, second: ['uint16', value]})
+    }
+    return base
+}
+
+export function buildModuleImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    const subtype = getModuleCapabilityType(itemId)
+    const item = getItem(itemId)
+    switch (subtype) {
+        case MODULE_ENGINE: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            base.push({first: 'volatility', second: ['uint16', vol]})
+            base.push({first: 'thermal', second: ['uint16', thm]})
+            base.push({first: 'thrust', second: ['uint32', computeEngineThrust(vol)]})
+            base.push({first: 'drain', second: ['uint16', computeEngineDrain(thm)]})
+            break
+        }
+        case MODULE_GENERATOR: {
+            const res = decodeStat(stats, 0)
+            const ref = decodeStat(stats, 1)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'capacity', second: ['uint16', computeGeneratorCap(res)]})
+            base.push({first: 'recharge', second: ['uint16', computeGeneratorRech(ref)]})
+            break
+        }
+        case MODULE_GATHERER: {
+            const str = decodeStat(stats, 0)
+            const tol = decodeStat(stats, 1)
+            const con = decodeStat(stats, 3)
+            base.push({first: 'strength', second: ['uint16', str]})
+            base.push({first: 'tolerance', second: ['uint16', tol]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
+            base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
+            base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})
+            break
+        }
+        case MODULE_LOADER: {
+            const fin = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
+            base.push({first: 'mass', second: ['uint32', computeLoaderMass(fin)]})
+            base.push({first: 'thrust', second: ['uint16', computeLoaderThrust(pla)]})
+            break
+        }
+        case MODULE_WARP: {
+            const res = decodeStat(stats, 0)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'range', second: ['uint32', computeWarpRange(res)]})
+            break
+        }
+        case MODULE_CRAFTER: {
+            const rea = decodeStat(stats, 0)
+            const com = decodeStat(stats, 1)
+            base.push({first: 'reactivity', second: ['uint16', rea]})
+            base.push({first: 'composition', second: ['uint16', com]})
+            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
+            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(com)]})
+            break
+        }
+        case MODULE_STORAGE: {
+            const str = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            const sat = decodeStat(stats, 2)
+            const sum = str + fin + sat
+            base.push({first: 'strength', second: ['uint16', str]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'saturation', second: ['uint16', sat]})
+            base.push({
+                first: 'capacity_bonus_pct',
+                second: ['uint16', 10 + Math.floor((sum * 10) / 2997)],
+            })
+            break
+        }
+        case MODULE_HAULER: {
+            const com = decodeStat(stats, 0)
+            const con = decodeStat(stats, 1)
+            const fin = decodeStat(stats, 2)
+            const res = decodeStat(stats, 3)
+            base.push({first: 'composition', second: ['uint16', com]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(com)]})
+            base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(con)]})
+            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(fin)]})
+            break
+        }
+    }
+    return base
+}
+
+export function buildEntityImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    modules: ImmutableModuleSlot[]
+): ImmutableEntry[] {
+    const moduleItems: number[] = []
+    const moduleStats: string[] = []
+    for (const m of modules) {
+        if (m.installed) {
+            moduleItems.push(Number(m.installed.item_id))
+            moduleStats.push(String(m.installed.stats))
+        } else {
+            moduleItems.push(0)
+            moduleStats.push('0')
+        }
+    }
+    const img = computeNftImageUrl({item_id: itemId, stats, modules, quantity}, originX, originY)
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    base.push({first: 'module_items', second: ['UINT16_VEC', moduleItems]})
+    base.push({first: 'module_stats', second: ['UINT64_VEC', moduleStats]})
+    const description = buildEntityDescription(
+        itemId,
+        stats,
+        moduleItems,
+        moduleStats.map((s) => BigInt(s))
+    )
+    base.push({first: 'description', second: ['string', description]})
+    return base
+}
+
+export function buildImmutableData(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    modules: ImmutableModuleSlot[] = []
+): ImmutableEntry[] {
+    const item = getItem(itemId)
+    if (item.type === 'resource') {
+        return buildResourceImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'component') {
+        return buildComponentImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'module') {
+        return buildModuleImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'entity') {
+        return buildEntityImmutable(itemId, quantity, stats, originX, originY, modules)
+    }
+    throw new Error(`Unsupported item type for wrap: ${item.type}`)
+}

package/src/nft/description.ts

@@ -56,7 +56,6 @@ export const computeGathererDrain = (con: number): number =>
     Math.max(250, 1250 - idiv(con * 25, 20))
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
-export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
@@ -133,12 +132,11 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const str = decodeStat(stats, 0)
             const tol = decodeStat(stats, 1)
             const con = decodeStat(stats, 3)
-            const ref = decodeStat(stats, 4)
             const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
                 tol,
                 tier
-            )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
+            )}  Drain ${computeGathererDrain(con)}`
             break
         }
         case MODULE_LOADER: {

package/src/nft/index.ts

@@ -2,3 +2,4 @@ export * from './deserializers'
 export * from './description'
 export * from './atomicdata'
 export * from './atomicassets'
+export * from './buildImmutableData'

package/src/resolution/describe-module.ts

@@ -53,14 +53,13 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     gatherer: {
         id: 'module.gatherer.description',
         template:
-            'mines resources at {yield} speed to a max depth of {depth} with {speed} gather speed while draining {drain} energy per second',
+            'mines resources at {yield} yield to a max depth of {depth} while draining {drain} energy per second',
         params: [
             ['yield', 'Yield'],
-            ['drain', 'Drain'],
             ['depth', 'Depth'],
-            ['speed', 'Speed'],
+            ['drain', 'Drain'],
         ],
-        highlightKeys: ['yield', 'depth', 'speed', 'drain'],
+        highlightKeys: ['yield', 'depth', 'drain'],
     },
     loader: {
         id: 'module.loader.description',

package/src/resolution/resolve-item.ts

@@ -189,7 +189,6 @@ function computeCapabilityGroup(
                     {label: 'Yield', value: caps.yield},
                     {label: 'Drain', value: caps.drain},
                     {label: 'Depth', value: caps.depth},
-                    {label: 'Speed', value: caps.speed},
                 ],
             }
         }

package/src/scheduling/projection.ts

@@ -255,7 +255,6 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             applyAddCargoTask(projected, task)
             break
         case TaskType.UNLOAD:
-        case TaskType.WRAP:
             applyRemoveCargoTask(projected, task)
             break
         case TaskType.GATHER:
@@ -268,7 +267,6 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             applyDeployTask(projected, task)
             break
         case TaskType.UNDEPLOY:
-        case TaskType.WRAP_ENTITY:
         case TaskType.DEMOLISH:
             break
     }
@@ -440,7 +438,6 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 if (taskComplete) applyAddCargoTask(projected, task)
                 break
             case TaskType.UNLOAD:
-            case TaskType.WRAP:
                 if (taskComplete) applyRemoveCargoTask(projected, task)
                 break
             case TaskType.GATHER:
@@ -453,7 +450,6 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 if (taskComplete) applyDeployTask(projected, task)
                 break
             case TaskType.UNDEPLOY:
-            case TaskType.WRAP_ENTITY:
             case TaskType.DEMOLISH:
                 break
         }

package/src/scheduling/task-cargo.ts

@@ -34,7 +34,6 @@ export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChan
         case TaskType.GATHER:
             return task.entitytarget ? [] : items.map((i) => toChange(i, 'in'))
         case TaskType.UNLOAD:
-        case TaskType.WRAP:
             return items.map((i) => toChange(i, 'out'))
         case TaskType.CRAFT:
             return [

package/src/shipload.ts

@@ -9,6 +9,7 @@ import type {PlayersManager} from './managers/players'
 import type {LocationsManager} from './managers/locations'
 import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
+import type {NftManager} from './managers/nft'
 import type {SubscriptionsManager} from './subscriptions/manager'
 import type {GameState} from './entities/gamestate'
 
@@ -107,6 +108,10 @@ export class Shipload {
         return this._context.actions
     }
 
+    get nft(): NftManager {
+        return this._context.nft
+    }
+
     get subscriptions(): SubscriptionsManager {
         return this._context.subscriptions
     }

package/src/types.ts

@@ -50,10 +50,8 @@ export enum TaskType {
     WARP = 6,
     CRAFT = 7,
     DEPLOY = 8,
-    WRAP = 9,
     UNWRAP = 10,
     UNDEPLOY = 11,
-    WRAP_ENTITY = 12,
     DEMOLISH = 13,
 }
 
@@ -119,6 +117,7 @@ export type ModuleType =
     | 'launcher'
     | 'storage'
     | 'hauler'
+    | 'battery'
 
 export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',