@shipload/sdk 1.0.0-next.0 → 1.0.0-next.10

package/src/managers/actions.ts

@@ -11,11 +11,11 @@ import {
     type UInt64Type,
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
+import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
 
 export type EntityRefInput = {
-    entityType: EntityTypeName
+    entityType: NameType
     entityId: UInt64Type
 }
 
@@ -25,7 +25,6 @@ export class ActionsManager extends BaseManager {
         const y = Int64.from(destination.y)
 
         return this.server.action('travel', {
-            entity_type: EntityType.SHIP,
             id: UInt64.from(shipId),
             x,
             y,
@@ -51,13 +50,8 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    resolve(
-        entityId: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP,
-        count?: UInt64Type
-    ): Action {
+    resolve(entityId: UInt64Type, count?: UInt64Type): Action {
         const params: ServerContract.ActionParams.resolve = {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         }
         if (count !== undefined) {
@@ -66,42 +60,34 @@ export class ActionsManager extends BaseManager {
         return this.server.action('resolve', params)
     }
 
-    cancel(
-        entityId: UInt64Type,
-        count: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    cancel(entityId: UInt64Type, count: UInt64Type): Action {
         return this.server.action('cancel', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             count: UInt64.from(count),
         })
     }
 
-    recharge(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
+    recharge(entityId: UInt64Type): Action {
         return this.server.action('recharge', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         })
     }
 
+    refrshentity(entityId: UInt64Type): Action {
+        return this.server.action('refrshentity', {
+            entity_id: UInt64.from(entityId),
+        })
+    }
+
     transfer(
-        sourceType: EntityTypeName,
         sourceId: UInt64Type,
-        destType: EntityTypeName,
         destId: UInt64Type,
-        itemId: UInt64Type,
-        stats: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         return this.server.action('transfer', {
-            source_type: sourceType,
             source_id: UInt64.from(sourceId),
-            dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(itemId),
-            stats: UInt64.from(stats),
-            quantity: UInt32.from(quantity),
+            items,
         })
     }
 
@@ -119,35 +105,24 @@ export class ActionsManager extends BaseManager {
     }
 
     gather(
-        source: EntityRefInput,
-        destination: EntityRefInput,
+        sourceId: UInt64Type,
+        destinationId: UInt64Type,
         stratum: UInt16Type,
         quantity: UInt32Type
     ): Action {
         return this.server.action('gather', {
-            source: ServerContract.Types.entity_ref.from({
-                entity_type: source.entityType,
-                entity_id: UInt64.from(source.entityId),
-            }),
-            destination: ServerContract.Types.entity_ref.from({
-                entity_type: destination.entityType,
-                entity_id: UInt64.from(destination.entityId),
-            }),
+            source_id: UInt64.from(sourceId),
+            destination_id: UInt64.from(destinationId),
             stratum: UInt16.from(stratum),
             quantity: UInt32.from(quantity),
         })
     }
 
-    warp(
-        entityId: UInt64Type,
-        destination: CoordinatesType,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    warp(entityId: UInt64Type, destination: CoordinatesType): Action {
         const x = Int64.from(destination.x)
         const y = Int64.from(destination.y)
 
         return this.server.action('warp', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             x,
             y,
@@ -155,92 +130,90 @@ export class ActionsManager extends BaseManager {
     }
 
     craft(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         recipeId: number,
         quantity: number,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('craft', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             recipe_id: UInt16.from(recipeId),
             quantity: UInt32.from(quantity),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    blend(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        inputs: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+    blend(entityId: UInt64Type, inputs: ServerContract.ActionParams.Type.cargo_item[]): Action {
         return this.server.action('blend', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    deploy(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        packedItemId: number,
-        stats: bigint
-    ): Action {
+    deploy(entityId: UInt64Type, ref: ServerContract.ActionParams.Type.cargo_ref): Action {
         return this.server.action('deploy', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            packed_item_id: UInt16.from(packedItemId),
-            stats: UInt64.from(stats),
+            ref,
         })
     }
 
     addmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        moduleCargoId: UInt64Type,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref,
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('addmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            module_cargo_id: UInt64.from(moduleCargoId),
-            target_cargo_id: UInt64.from(targetCargoId),
+            module_ref: moduleRef,
+            target_ref: targetRef ?? undefined,
         })
     }
 
     rmmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('rmmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            target_cargo_id: UInt64.from(targetCargoId),
+            target_ref: targetRef ?? undefined,
         })
     }
 
     wrap(
         owner: NameType,
-        entityType: EntityTypeName,
         entityId: UInt64Type,
-        cargoId: UInt64Type,
-        quantity: UInt64Type
+        nexusId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         return this.server.action('wrap', {
             owner: Name.from(owner),
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
+            nexus_id: UInt64.from(nexusId),
+            items,
+        })
+    }
+
+    undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
+        return this.server.action('undeploy', {
+            host_id: UInt64.from(hostId),
+            target_id: UInt64.from(targetId),
+        })
+    }
+
+    wrapEntity(entityId: UInt64Type, nexusId: UInt64Type): Action {
+        return this.server.action('wrapentity', {
+            entity_id: UInt64.from(entityId),
+            nexus_id: UInt64.from(nexusId),
+        })
+    }
+
+    demolish(entityId: UInt64Type): Action {
+        return this.server.action('demolish', {
+            entity_id: UInt64.from(entityId),
         })
     }
 

package/src/managers/entities.ts

@@ -3,14 +3,14 @@ import {BaseManager} from './base'
 import {Ship} from '../entities/ship'
 import {Warehouse} from '../entities/warehouse'
 import {Container} from '../entities/container'
+import {Extractor} from '../entities/extractor'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+export type EntityType = 'ship' | 'warehouse' | 'extractor' | 'container'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+    async getEntity(id: UInt64Type): Promise<Ship | Warehouse | Extractor | Container> {
         const result = await this.server.readonly('getentity', {
-            entity_type: Name.from(type),
             entity_id: id,
         })
         const entityInfo = result as ServerContract.Types.entity_info
@@ -20,11 +20,11 @@ export class EntitiesManager extends BaseManager {
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
         type?: EntityType
-    ): Promise<(Ship | Warehouse | Container)[]> {
+    ): Promise<(Ship | Warehouse | Extractor | Container)[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: type,
         })
         const entities = result as ServerContract.Types.entity_info[]
         return entities.map((entity) => this.wrapEntity(entity))
@@ -37,21 +37,25 @@ export class EntitiesManager extends BaseManager {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getsummaries', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: type,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
     async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity('ship', id)) as Ship
+        return (await this.getEntity(id)) as Ship
     }
 
     async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity('warehouse', id)) as Warehouse
+        return (await this.getEntity(id)) as Warehouse
     }
 
     async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity('container', id)) as Container
+        return (await this.getEntity(id)) as Container
+    }
+
+    async getExtractor(id: UInt64Type): Promise<Extractor> {
+        return (await this.getEntity(id)) as Extractor
     }
 
     async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
@@ -66,6 +70,10 @@ export class EntitiesManager extends BaseManager {
         return (await this.getEntities(owner, 'container')) as Container[]
     }
 
+    async getExtractors(owner: NameType | ServerContract.Types.player_row): Promise<Extractor[]> {
+        return (await this.getEntities(owner, 'extractor')) as Extractor[]
+    }
+
     async getShipSummaries(
         owner: NameType | ServerContract.Types.player_row
     ): Promise<ServerContract.Types.entity_summary[]> {
@@ -84,14 +92,20 @@ export class EntitiesManager extends BaseManager {
         return this.getSummaries(owner, 'container')
     }
 
-    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse | Container {
-        if (entity.type.equals('ship')) {
-            return new Ship(entity)
-        } else if (entity.type.equals('warehouse')) {
-            return new Warehouse(entity)
-        } else {
-            return new Container(entity)
-        }
+    async getExtractorSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'extractor')
+    }
+
+    private wrapEntity(
+        entity: ServerContract.Types.entity_info
+    ): Ship | Warehouse | Extractor | Container {
+        if (entity.type.equals('ship')) return new Ship(entity)
+        if (entity.type.equals('warehouse')) return new Warehouse(entity)
+        if (entity.type.equals('extractor')) return new Extractor(entity)
+        if (entity.type.equals('container')) return new Container(entity)
+        throw new Error(`unknown entity type: ${entity.type}`)
     }
 
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {

package/src/managers/locations.ts

@@ -1,6 +1,6 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import type {UInt16Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, coordsToLocationId, type Distance} from '../types'
+import type {CoordinatesType, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import type {ServerContract} from '../contracts'
@@ -47,22 +47,4 @@ export class LocationsManager extends BaseManager {
             reserve: overrideMap.get(s.index) ?? s.reserve,
         }))
     }
-
-    async getLocationEntity(
-        id: UInt64Type
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const row = await this.server.table('location').get(UInt64.from(id))
-        return row ?? undefined
-    }
-
-    async getLocationEntityAt(
-        coords: CoordinatesType
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const id = coordsToLocationId(coords)
-        return this.getLocationEntity(id)
-    }
-
-    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
-        return this.server.table('location').all()
-    }
 }

package/src/nft/atomicdata.ts

@@ -0,0 +1,125 @@
+export interface SchemaField {
+    name: string
+    type: string
+}
+
+export type RawData =
+    | Uint8Array
+    | string
+    | number[]
+    | {immutable_serialized_data: Uint8Array | string | number[]}
+
+export function deserializeAtomicData(
+    data: RawData,
+    schema: SchemaField[]
+): Record<string, unknown> {
+    let rawData: Uint8Array | string | number[]
+    if (data && typeof data === 'object' && 'immutable_serialized_data' in (data as object)) {
+        rawData = (data as {immutable_serialized_data: Uint8Array | string | number[]})
+            .immutable_serialized_data
+    } else {
+        rawData = data as Uint8Array | string | number[]
+    }
+
+    let bytes: Uint8Array
+    if (typeof rawData === 'string') {
+        const hex = rawData
+        bytes = new Uint8Array(hex.length / 2)
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16)
+        }
+    } else if (Array.isArray(rawData)) {
+        bytes = new Uint8Array(rawData)
+    } else {
+        bytes = rawData
+    }
+
+    let offset = 0
+
+    function readVarint(): number {
+        let result = 0
+        let multiplier = 1
+        while (bytes[offset] >= 128) {
+            result += (bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128
+        }
+        result += bytes[offset] * multiplier
+        offset++
+        return result
+    }
+
+    function readVarint64(): bigint {
+        let result = 0n
+        let multiplier = 1n
+        while (bytes[offset] >= 128) {
+            result += BigInt(bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128n
+        }
+        result += BigInt(bytes[offset]) * multiplier
+        offset++
+        return result
+    }
+
+    function readZigzagInt64(): bigint {
+        const unsigned = readVarint64()
+        if (unsigned % 2n === 0n) {
+            return unsigned / 2n
+        } else {
+            return -(unsigned / 2n) - 1n
+        }
+    }
+
+    function readString(): string {
+        const length = readVarint()
+        const str = new TextDecoder().decode(bytes.slice(offset, offset + length))
+        offset += length
+        return str
+    }
+
+    const RESERVED = 4
+    const result: Record<string, unknown> = {}
+
+    while (offset < bytes.length) {
+        const fieldIndex = readVarint() - RESERVED
+        const field = schema[fieldIndex]
+        if (!field) break
+
+        switch (field.type) {
+            case 'uint16':
+                result[field.name] = readVarint()
+                break
+            case 'uint32':
+                result[field.name] = readVarint()
+                break
+            case 'uint64':
+                result[field.name] = readVarint64()
+                break
+            case 'int64':
+                result[field.name] = readZigzagInt64()
+                break
+            case 'string':
+                result[field.name] = readString()
+                break
+            case 'uint16[]': {
+                const len = readVarint()
+                const arr: number[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint())
+                result[field.name] = arr
+                break
+            }
+            case 'uint64[]': {
+                const len = readVarint()
+                const arr: bigint[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint64())
+                result[field.name] = arr
+                break
+            }
+            default:
+                throw new Error(`Unknown type: ${field.type}`)
+        }
+    }
+
+    return result
+}

package/src/nft/description.ts

@@ -4,22 +4,29 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
+    MODULE_WARP,
 } from '../capabilities/modules'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
     ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../entities/ship-deploy'
+import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -27,7 +34,7 @@ function idiv(a: number, b: number): number {
 
 export function computeBaseHullmass(stats: bigint): number {
     const density = decodeStat(stats, 1)
-    return 25000 + 75 * density
+    return 100000 - 75 * density
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
@@ -42,17 +49,22 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
-export const computeGeneratorRech = (ref: number): number => 1 + idiv(ref * 3, 1000)
+export const computeGeneratorCap = (com: number): number => 300 + idiv(com, 6)
+export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1000)
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
     Math.max(250, 1250 - idiv(con * 25, 20))
-export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+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 = (fin: number): number => Math.max(200, 2000 - fin * 2)
+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)
-export const computeCrafterDrain = (com: number): number => Math.max(5, 30 - idiv(com, 33))
+export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
+export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
+export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
+export const computeWarpRange = (stat: number): number => 100 + stat * 3
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
@@ -60,6 +72,8 @@ export function entityDisplayName(itemId: number): string {
             return 'Ship'
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return 'Extractor'
         case ITEM_CONTAINER_T1_PACKED:
             return 'Container'
         case ITEM_CONTAINER_T2_PACKED:
@@ -83,6 +97,10 @@ export function moduleDisplayName(itemId: number): string {
             return 'Crafter'
         case ITEM_STORAGE_T1:
             return 'Storage'
+        case ITEM_HAULER_T1:
+            return 'Hauler'
+        case ITEM_WARP_T1:
+            return 'Warp'
         default:
             return 'Module'
     }
@@ -116,8 +134,10 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             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
+                tol,
+                tier
             )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
@@ -142,6 +162,18 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  +${pct}% capacity`
             break
         }
+        case MODULE_HAULER: {
+            const fin = decodeStat(stats, 0)
+            const con = decodeStat(stats, 1)
+            const com = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            break
+        }
+        case MODULE_WARP: {
+            const stat = decodeStat(stats, 0)
+            out += `  Range ${computeWarpRange(stat)}`
+            break
+        }
     }
     return out
 }
@@ -158,6 +190,8 @@ export function buildEntityDescription(
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)
+    } else if (itemId === ITEM_EXTRACTOR_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullStats)
     }
 
     let out = entityDisplayName(itemId)

package/src/nft/index.ts

@@ -1,2 +1,3 @@
 export * from './deserializers'
 export * from './description'
+export * from './atomicdata'