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

package/src/data/capabilities.ts

@@ -21,6 +21,7 @@ export const capabilityNames: string[] = [
     'Crafter',
     'Launch',
     'Hauler',
+    'Battery',
 ]
 
 export const capabilityAttributes: CapabilityAttribute[] = [
@@ -40,7 +41,6 @@ export const capabilityAttributes: CapabilityAttribute[] = [
     {capability: 'Gathering', attribute: 'yield', description: 'Mass gathered per second'},
     {capability: 'Gathering', attribute: 'drain', description: 'Energy consumed per gather'},
     {capability: 'Gathering', attribute: 'depth', description: 'Maximum gather depth'},
-    {capability: 'Gathering', attribute: 'speed', description: 'Gathering speed/penetration'},
     {capability: 'Warp', attribute: 'range', description: 'Maximum warp distance'},
     {capability: 'Crafter', attribute: 'speed', description: 'Crafting time per item'},
     {
@@ -67,6 +67,11 @@ export const capabilityAttributes: CapabilityAttribute[] = [
         attribute: 'drain',
         description: 'Energy consumed per target during haul-beam operation',
     },
+    {
+        capability: 'Battery',
+        attribute: 'bonus',
+        description: 'Energy capacity bonus added by an installed Battery module',
+    },
 ]
 
 const invertedAttributes = new Set(['drain', 'mass'])

package/src/data/capability-formulas.ts

@@ -12,6 +12,7 @@ export type SlotConsumerKind =
     | 'storage'
     | 'hauler'
     | 'warp'
+    | 'battery'
     | 'ship-t1'
     | 'container-t1'
     | 'warehouse-t1'
@@ -38,7 +39,6 @@ export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer
         0: {capability: 'Gathering', attribute: 'yield'},
         1: {capability: 'Gathering', attribute: 'depth'},
         3: {capability: 'Gathering', attribute: 'drain'},
-        4: {capability: 'Gathering', attribute: 'speed'},
     },
     loader: {
         0: {capability: 'Loader', attribute: 'mass'},
@@ -62,6 +62,12 @@ export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer
     warp: {
         0: {capability: 'Warp', attribute: 'range'},
     },
+    battery: {
+        0: {capability: 'Battery', attribute: 'bonus'},
+        1: {capability: 'Battery', attribute: 'bonus'},
+        2: {capability: 'Battery', attribute: 'bonus'},
+        3: {capability: 'Battery', attribute: 'bonus'},
+    },
     'ship-t1': ENTITY_HULL_SLOTS,
     'container-t1': ENTITY_HULL_SLOTS,
     'warehouse-t1': ENTITY_HULL_SLOTS,

package/src/data/colors.ts

@@ -43,16 +43,16 @@ export const componentIcon = '▣'
 export const moduleIcon = '⬢'
 
 export const itemAbbreviations: Record<number, string> = {
-    10001: 'HP',
-    10002: 'CL',
-    10003: 'TC',
-    10004: 'PC',
-    10005: 'DS',
-    10006: 'EP',
-    10007: 'CA',
-    10008: 'TB',
-    10009: 'RC',
-    10010: 'FA',
+    10001: 'PL',
+    10002: 'FR',
+    10003: 'PC',
+    10004: 'RS',
+    10005: 'BM',
+    10006: 'SN',
+    10007: 'PM',
+    10008: 'CR',
+    10009: 'RX',
+    10010: 'EM',
     10100: 'EN',
     10101: 'GN',
     10102: 'EX',
@@ -64,7 +64,7 @@ export const itemAbbreviations: Record<number, string> = {
     10200: 'CT',
     10201: 'SH',
     10202: 'WH',
-    20001: 'HP',
-    20002: 'CL',
+    20001: 'PL',
+    20002: 'FR',
     20200: 'CT',
 }

package/src/data/item-ids.ts

@@ -50,16 +50,16 @@ export const ITEM_BIOMASS_T7 = 507
 export const ITEM_BIOMASS_T8 = 508
 export const ITEM_BIOMASS_T9 = 509
 export const ITEM_BIOMASS_T10 = 510
-export const ITEM_HULL_PLATES = 10001
-export const ITEM_CARGO_LINING = 10002
-export const ITEM_THRUSTER_CORE = 10003
-export const ITEM_POWER_CELL = 10004
-export const ITEM_MATTER_CONDUIT = 10005
-export const ITEM_SURVEY_PROBE = 10006
-export const ITEM_CARGO_ARM = 10007
-export const ITEM_TOOL_BIT = 10008
-export const ITEM_REACTION_CHAMBER = 10009
-export const ITEM_FOCUSING_ARRAY = 10010
+export const ITEM_PLATE = 10001
+export const ITEM_FRAME = 10002
+export const ITEM_PLASMA_CELL = 10003
+export const ITEM_RESONATOR = 10004
+export const ITEM_BEAM = 10005
+export const ITEM_SENSOR = 10006
+export const ITEM_POLYMER = 10007
+export const ITEM_CERAMIC = 10008
+export const ITEM_REACTOR = 10009
+export const ITEM_EMITTER = 10010
 export const ITEM_ENGINE_T1 = 10100
 export const ITEM_GENERATOR_T1 = 10101
 export const ITEM_GATHERER_T1 = 10102
@@ -68,11 +68,12 @@ export const ITEM_CRAFTER_T1 = 10104
 export const ITEM_STORAGE_T1 = 10105
 export const ITEM_HAULER_T1 = 10106
 export const ITEM_WARP_T1 = 10107
+export const ITEM_BATTERY_T1 = 10108
 export const ITEM_CONTAINER_T1_PACKED = 10200
 export const ITEM_SHIP_T1_PACKED = 10201
 export const ITEM_WAREHOUSE_T1_PACKED = 10202
 export const ITEM_EXTRACTOR_T1_PACKED = 10203
 export const ITEM_FACTORY_T1_PACKED = 10204
-export const ITEM_HULL_PLATES_T2 = 20001
-export const ITEM_CARGO_LINING_T2 = 20002
+export const ITEM_PLATE_T2 = 20001
+export const ITEM_FRAME_T2 = 20002
 export const ITEM_CONTAINER_T2_PACKED = 20200

package/src/data/items.json

@@ -465,6 +465,13 @@
     "tier": 1,
     "subtype": "warp"
   },
+  {
+    "id": 10108,
+    "mass": 90000,
+    "type": "module",
+    "tier": 1,
+    "subtype": "battery"
+  },
   {
     "id": 10200,
     "mass": 80000,

package/src/data/metadata.ts

@@ -109,56 +109,63 @@ export const itemMetadata: Record<number, ItemMetadata> = {
 
     // === Components (T1) ===
     10001: {
-        name: 'Hull Plates',
-        description: 'Structural plating formed from ore. Used in hulls, containers, and frames.',
+        name: 'Plate',
+        description:
+            'Structural plating formed from ore. Used in hulls, containers, and storage modules.',
         color: '#7B8D9E',
     },
     10002: {
-        name: 'Cargo Lining',
+        name: 'Frame',
         description:
-            'Composite lining formed from fine regolith bound in biomass polymer. Dense enough to seal cargo holds, flexible enough to absorb vibration.',
+            'Composite framing formed from fine regolith bound in biomass polymer. Dense enough to seal cargo holds, flexible enough to absorb vibration.',
         color: '#C4A57B',
     },
     10003: {
-        name: 'Thruster Core',
-        description: 'High-energy propulsion component formed from volatile gases.',
+        name: 'Plasma Cell',
+        description:
+            'High-energy gaseous storage cell. Volatile gas held under controlled thermal conditions.',
         color: '#E86344',
     },
     10004: {
-        name: 'Power Cell',
+        name: 'Resonator',
         description:
-            'Crystalline energy storage matrix. Resonant lattices retain and release charge.',
+            'Crystalline resonance lattice. Stores and releases charge through coherent oscillation.',
         color: '#4ADBFF',
     },
     10005: {
-        name: 'Matter Conduit',
-        description: 'Heavy-duty ore shaft used in gathering equipment.',
+        name: 'Beam',
+        description:
+            'Heavy-duty structural beam machined from refined ore. Strong enough to bear load, tolerant enough to survive harsh environments.',
         color: '#7B8D9E',
     },
     10006: {
-        name: 'Survey Probe',
-        description: 'Crystal-lattice sensor array for deep resource detection.',
+        name: 'Sensor',
+        description:
+            'Crystal-lattice sensing element with conductive and reflective properties. Reads signal and surface alike.',
         color: '#4ADBFF',
     },
     10007: {
-        name: 'Cargo Arm',
-        description: 'Flexible biomass composite arm for cargo handling.',
+        name: 'Polymer',
+        description:
+            'Pliable biomass-derived polymer with high insulation. Flexible, durable, electrically inert.',
         color: '#5A8B3E',
     },
     10008: {
-        name: 'Tool Bit',
-        description: 'Dense regolith cutting head for crafting operations.',
+        name: 'Ceramic',
+        description:
+            'Hardened fine-grained ceramic refined from regolith. Hard enough to cut, fine enough to finish.',
         color: '#C4A57B',
     },
     10009: {
-        name: 'Reaction Chamber',
-        description: 'Gas-pressurized vessel for controlled crafting reactions.',
+        name: 'Reactor',
+        description:
+            'Gas-pressurized vessel for controlled reactions. Vents heat and contains volatility.',
         color: '#B8E4A0',
     },
     10010: {
-        name: 'Focusing Array',
+        name: 'Emitter',
         description:
-            "Precision-formed crystal lens array. Routes the haul beam's energy efficiently to the target lock.",
+            'Precision-formed crystal emitter array. Routes energy efficiently to a target lock.',
         color: '#4ADBFF',
     },
 
@@ -206,6 +213,12 @@ export const itemMetadata: Record<number, ItemMetadata> = {
             'Folds local space-time around the hull, projecting the ship across vast distances in a single discharge of the entire energy reserve.',
         color: '#9be4ff',
     },
+    10108: {
+        name: 'Battery',
+        description:
+            'Extends energy capacity. Stores additional charge produced by generators, letting builds chain more high-drain actions between recharges.',
+        color: '#4ADBFF',
+    },
 
     // === Entities (packed, T1) ===
     10200: {
@@ -237,14 +250,14 @@ export const itemMetadata: Record<number, ItemMetadata> = {
 
     // === Components (T2) ===
     20001: {
-        name: 'Hull Plates',
+        name: 'Plate',
         description: 'Advanced structural plating reinforced with tier 2 ore.',
         color: '#9BADB8',
     },
     20002: {
-        name: 'Cargo Lining',
+        name: 'Frame',
         description:
-            'Advanced composite lining reinforced with tier 2 regolith and biomass polymer.',
+            'Advanced composite framing reinforced with tier 2 regolith and biomass polymer.',
         color: '#C4A57B',
     },
 

package/src/data/recipes.json

@@ -605,6 +605,55 @@
       1
     ]
   },
+  {
+    "outputItemId": 10108,
+    "outputMass": 90000,
+    "inputs": [
+      {
+        "itemId": 10003,
+        "quantity": 4
+      },
+      {
+        "itemId": 10007,
+        "quantity": 3
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 1
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 1,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 1,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
   {
     "outputItemId": 10200,
     "outputMass": 80000,

package/src/derivation/capabilities.ts

@@ -75,18 +75,15 @@ export function computeGathererCapabilities(
     yield: number
     drain: number
     depth: number
-    speed: number
 } {
     const str = stats.strength
     const con = stats.conductivity
-    const ref = stats.reflectivity
     const tol = stats.tolerance
 
     return {
         yield: 200 + str,
         drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
         depth: gathererDepthForTier(tol, tier),
-        speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
 
@@ -163,6 +160,7 @@ import {
 } from '../data/item-ids'
 import {
     getModuleCapabilityType,
+    MODULE_BATTERY,
     MODULE_ENGINE,
     MODULE_GENERATOR,
     MODULE_GATHERER,
@@ -222,7 +220,7 @@ export interface ComputedCapabilities {
     capacity: number
     engines?: {thrust: number; drain: number}
     generator?: {capacity: number; recharge: number}
-    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+    gatherer?: {yield: number; drain: number; depth: number}
     loaders?: {mass: number; thrust: number; quantity: number}
     crafter?: {speed: number; drain: number}
     hauler?: {capacity: number; efficiency: number; drain: number}
@@ -251,7 +249,6 @@ export function computeEntityCapabilities(
     let totalGathYield = 0
     let totalGathDrain = 0
     let maxGathDepth = 0
-    let totalGathSpeed = 0
     let hasGatherer = false
 
     let totalStorageBonus = 0
@@ -270,6 +267,9 @@ export function computeEntityCapabilities(
     let totalWarpRange = 0
     let hasWarp = false
 
+    let totalBatteryStatSum = 0
+    let batteryCount = 0
+
     for (const mod of modules) {
         const item = getItem(mod.itemId)
         const modType = getModuleCapabilityType(mod.itemId)
@@ -294,7 +294,6 @@ export function computeEntityCapabilities(
             totalGathYield += applySlotMultiplier(caps.yield, amp)
             totalGathDrain += caps.drain
             if (caps.depth > maxGathDepth) maxGathDepth = caps.depth
-            totalGathSpeed += applySlotMultiplier(caps.speed, amp)
         } else if (modType === MODULE_LOADER) {
             hasLoader = true
             const caps = computeLoaderCapabilities(decodedStats)
@@ -320,9 +319,22 @@ export function computeEntityCapabilities(
             hasWarp = true
             const caps = computeWarpCapabilities(decodedStats)
             totalWarpRange += applySlotMultiplier(caps.range, amp)
+        } else if (modType === MODULE_BATTERY) {
+            batteryCount++
+            const vol = decodedStats.volatility ?? 0
+            const thm = decodedStats.thermal ?? 0
+            const pla = decodedStats.plasticity ?? 0
+            const ins = decodedStats.insulation ?? 0
+            totalBatteryStatSum += vol + thm + pla + ins
         }
     }
 
+    if (hasGenerator && batteryCount > 0) {
+        const genCapBase = totalGenCapacity
+        const bonusPctNum = 10 * batteryCount + Math.floor((totalBatteryStatSum * 10) / 2997)
+        totalGenCapacity += Math.floor((genCapBase * bonusPctNum) / 100)
+    }
+
     const result: ComputedCapabilities = {
         hullmass: computeBaseHullmass(stats) + installedModuleMass,
         capacity: baseCapacity + totalStorageBonus,
@@ -342,7 +354,6 @@ export function computeEntityCapabilities(
             yield: clampUint16(totalGathYield),
             drain: totalGathDrain,
             depth: maxGathDepth,
-            speed: clampUint16(totalGathSpeed),
         }
     }
     if (hasLoader) {

package/src/derivation/capability-mappings.ts

@@ -16,6 +16,7 @@ import {
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
     ITEM_WARP_T1,
+    ITEM_BATTERY_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_CONTAINER_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
@@ -32,6 +33,7 @@ export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     storage: ITEM_STORAGE_T1,
     hauler: ITEM_HAULER_T1,
     warp: ITEM_WARP_T1,
+    battery: ITEM_BATTERY_T1,
     'ship-t1': ITEM_SHIP_T1_PACKED,
     'container-t1': ITEM_CONTAINER_T1_PACKED,
     'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,

package/src/derivation/stratum.ts

@@ -76,15 +76,11 @@ export function deriveStratum(
         (BigInt(bytes[14]) << 8n) |
         BigInt(bytes[15])
 
-    const rawRichness = (bytes[16] << 8) | bytes[17]
-    const normalized = rawRichness / 65535
-    const baseRichness = Math.floor(normalized * normalized * 999) + 1
-
-    let depthBonus = 0
-    if (stratum > 1) {
-        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
-    }
-    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+    let byteSum = 0
+    for (let i = 22; i <= 33; i++) byteSum += bytes[i]
+    const z = (byteSum - 1530) / 256
+    const roll = 500 + 100 * z
+    const richness = Math.max(1, Math.min(999, Math.round(roll)))
 
     return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
 }

package/src/index-module.ts

@@ -47,8 +47,9 @@ export {
     LocationsManager,
     EpochsManager,
     ActionsManager,
+    NftManager,
 } from './managers'
-export type {LocationStratum} from './managers'
+export type {LocationStratum, NftConfigForItem} from './managers'
 export type {EntityRefInput} from './managers/actions'
 
 export {
@@ -331,10 +332,25 @@ export type {
 export {deserializeAtomicData} from './nft/atomicdata'
 export type {SchemaField, RawData} from './nft/atomicdata'
 
+export {
+    buildImmutableData,
+    buildResourceImmutable,
+    buildComponentImmutable,
+    buildModuleImmutable,
+    buildEntityImmutable,
+    computeNftImageUrl,
+} from './nft/buildImmutableData'
+export type {
+    AtomicAttributeType,
+    ImmutableEntry,
+    ImmutableModuleSlot,
+} from './nft/buildImmutableData'
+
 export {
     fetchAtomicAssetsForOwner,
     fetchAtomicSchemas,
     decodeAtomicAsset,
+    buildMintAssetAction,
     ATOMICASSETS_ACCOUNT,
     SHIPLOAD_COLLECTION,
 } from './nft/atomicassets'
@@ -343,6 +359,7 @@ export type {
     AtomicSchemaRow,
     DecodedAtomicAsset,
     FetchAssetsOptions,
+    MintAssetParams,
 } from './nft/atomicassets'
 
 export {
@@ -360,7 +377,6 @@ export {
     computeGathererYield,
     computeGathererDrain,
     computeGathererDepth,
-    computeGathererSpeed,
     computeLoaderMass,
     computeLoaderThrust,
     computeCrafterSpeed,

package/src/managers/actions.ts

@@ -13,6 +13,12 @@ import {
 import {BaseManager} from './base'
 import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
+import {
+    buildImmutableData,
+    type ImmutableModuleSlot,
+    moduleSlotsForImmutable,
+} from '../nft/buildImmutableData'
+import {buildMintAssetAction, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 
 export type EntityRefInput = {
     entityType: NameType
@@ -183,18 +189,81 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    wrap(
+    private async buildPairedMintAction(args: {
+        owner: NameType
+        itemId: number
+        quantity: number
+        stats: bigint
+        originX: number
+        originY: number
+        moduleSlots: ImmutableModuleSlot[]
+    }): Promise<Action> {
+        const nftCfg = await this.context.nft.getNftConfigForItem(args.itemId)
+        if (!nftCfg) {
+            throw new Error(`item ${args.itemId} has no nftconfig`)
+        }
+        const immutableData = buildImmutableData(
+            args.itemId,
+            args.quantity,
+            args.stats,
+            args.originX,
+            args.originY,
+            args.moduleSlots
+        )
+        return buildMintAssetAction({
+            authorizedMinter: Name.from(args.owner),
+            collectionName: SHIPLOAD_COLLECTION,
+            schemaName: nftCfg.schemaName,
+            templateId: nftCfg.templateId,
+            newAssetOwner: Name.from(args.owner),
+            immutableData,
+        })
+    }
+
+    async wrap(
         owner: NameType,
         entityId: UInt64Type,
         nexusId: UInt64Type,
-        items: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action {
-        return this.server.action('wrap', {
-            owner: Name.from(owner),
-            entity_id: UInt64.from(entityId),
-            nexus_id: UInt64.from(nexusId),
-            items,
+        cargoId: UInt64Type,
+        quantity: UInt64Type
+    ): Promise<Action[]> {
+        const cargoIdKey = UInt64.from(cargoId)
+        const entityIdKey = UInt64.from(entityId)
+        const [cargoRow, entityRow] = (await Promise.all([
+            this.server.table('cargo').get(cargoIdKey),
+            this.server.table('entity').get(entityIdKey),
+        ])) as [
+            ServerContract.Types.cargo_row | undefined,
+            ServerContract.Types.entity_row | undefined,
+        ]
+        if (!cargoRow) {
+            throw new Error(`cargo row ${cargoIdKey} not found`)
+        }
+        if (!entityRow) {
+            throw new Error(`entity ${entityIdKey} not found`)
+        }
+
+        const quantityValue = UInt64.from(quantity)
+        const mintAction = await this.buildPairedMintAction({
+            owner,
+            itemId: Number(cargoRow.item_id.toString()),
+            quantity: Number(quantityValue.toString()),
+            stats: BigInt(cargoRow.stats.toString()),
+            originX: Number(entityRow.coordinates.x.toString()),
+            originY: Number(entityRow.coordinates.y.toString()),
+            moduleSlots: moduleSlotsForImmutable(cargoRow.modules),
         })
+
+        return [
+            this.server.action('wrap', {
+                owner: Name.from(owner),
+                entity_id: UInt64.from(entityId),
+                nexus_id: UInt64.from(nexusId),
+                cargo_id: cargoIdKey,
+                quantity: quantityValue,
+            }),
+            mintAction,
+        ]
     }
 
     undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
@@ -204,11 +273,54 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    wrapEntity(entityId: UInt64Type, nexusId: UInt64Type): Action {
-        return this.server.action('wrapentity', {
-            entity_id: UInt64.from(entityId),
-            nexus_id: UInt64.from(nexusId),
+    async wrapEntity(
+        owner: NameType,
+        entityId: UInt64Type,
+        nexusId: UInt64Type
+    ): Promise<Action[]> {
+        const entityIdKey = UInt64.from(entityId)
+        const entityRow = (await this.server.table('entity').get(entityIdKey)) as
+            | ServerContract.Types.entity_row
+            | undefined
+        if (!entityRow) {
+            throw new Error(`entity ${entityIdKey} not found`)
+        }
+
+        const mintAction = await this.buildPairedMintAction({
+            owner,
+            itemId: Number(entityRow.item_id.toString()),
+            quantity: 1,
+            stats: BigInt(entityRow.stats.toString()),
+            originX: Number(entityRow.coordinates.x.toString()),
+            originY: Number(entityRow.coordinates.y.toString()),
+            moduleSlots: moduleSlotsForImmutable(entityRow.modules),
         })
+
+        return [
+            this.server.action('wrapentity', {
+                entity_id: entityIdKey,
+                nexus_id: UInt64.from(nexusId),
+            }),
+            mintAction,
+        ]
+    }
+
+    deploynft(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.deploynft = {
+            owner: Name.from(owner),
+            asset_id: UInt64.from(assetId),
+            target_nexus_id: UInt64.from(targetNexusId),
+        }
+        return this.server.action('deploynft', params)
+    }
+
+    unwrapnft(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.unwrapnft = {
+            owner: Name.from(owner),
+            asset_id: UInt64.from(assetId),
+            host_id: UInt64.from(hostId),
+        }
+        return this.server.action('unwrapnft', params)
     }
 
     demolish(entityId: UInt64Type): Action {