@shipload/sdk 1.0.0-next.7 → 1.0.0-next.70

package/src/types/capabilities.ts

@@ -1,13 +1,35 @@
-import type {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import type {Name, UInt32, UInt8} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
 
+export interface LoaderStats {
+    mass: {toNumber(): number; multiplying(v: unknown): {toNumber(): number}}
+    thrust: {toNumber(): number}
+    quantity: {toNumber(): number; gt(v: unknown): boolean}
+}
+
+export interface GathererStats {
+    yield: {toNumber(): number}
+    drain: {toNumber(): number}
+    depth: {toNumber(): number; toString(): string}
+}
+
+export interface CrafterStats {
+    speed: {toNumber(): number}
+    drain: {toNumber(): number}
+}
+
+export interface BuilderStats {
+    speed: {toNumber(): number}
+    drain: {toNumber(): number}
+}
+
 export interface MovementCapability {
     engines: ServerContract.Types.movement_stats
     generator: ServerContract.Types.energy_stats
 }
 
 export interface EnergyCapability {
-    energy: UInt16
+    energy: UInt32
 }
 
 export interface StorageCapability {
@@ -17,11 +39,11 @@ export interface StorageCapability {
 }
 
 export interface LoaderCapability {
-    loaders: ServerContract.Types.loader_stats
+    loaders: LoaderStats
 }
 
 export interface GathererCapability {
-    gatherer: ServerContract.Types.gatherer_stats
+    gatherer: GathererStats
 }
 
 export interface MassCapability {
@@ -29,6 +51,7 @@ export interface MassCapability {
 }
 
 export interface ScheduleCapability {
+    lanes?: ServerContract.Types.lane[]
     schedule?: ServerContract.Types.schedule
 }
 
@@ -37,16 +60,18 @@ export interface EntityCapabilities {
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
-    gatherer?: ServerContract.Types.gatherer_stats
-    crafter?: ServerContract.Types.crafter_stats
+    loaders?: LoaderStats
+    gatherer?: GathererStats
+    crafter?: CrafterStats
+    builder?: BuilderStats
     hauler?: ServerContract.Types.hauler_stats
+    launcher?: ServerContract.Types.launcher_stats
 }
 
 export interface EntityState {
     owner: Name
     location: ServerContract.Types.coordinates
-    energy?: UInt16
+    energy?: UInt32
     cargomass: UInt32
     cargo: ServerContract.Types.cargo_item[]
 }
@@ -74,3 +99,7 @@ export function capsHasMass(caps: EntityCapabilities): boolean {
 export function capsHasHauler(caps: EntityCapabilities): boolean {
     return caps.hauler !== undefined
 }
+
+export function capsHasLauncher(caps: EntityCapabilities): boolean {
+    return caps.launcher !== undefined
+}

package/src/types/entity.ts

@@ -3,6 +3,7 @@ import type {ServerContract} from '../contracts'
 import type {Coordinates} from '../types'
 import type {
     EnergyCapability,
+    GathererCapability,
     LoaderCapability,
     MassCapability,
     MovementCapability,
@@ -24,9 +25,8 @@ export type ShipEntity = Entity &
     StorageCapability &
     Partial<LoaderCapability> &
     MassCapability &
-    ScheduleCapability & {
-        gatherer?: ServerContract.Types.gatherer_stats
-    }
+    ScheduleCapability &
+    Partial<GathererCapability>
 
 export type WarehouseEntity = Entity &
     StorageCapability &

package/src/types/index.ts

@@ -1,3 +1,2 @@
 export * from './capabilities'
 export * from './entity'
-export * from './entity-traits'

package/src/types.ts

@@ -1,35 +1,50 @@
 import {
     type Int64Type,
-    Name,
     type UInt16,
     type UInt16Type,
     type UInt32,
     type UInt32Type,
     UInt64,
+    type UInt64Type,
 } from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
+import {COORD_MAX, COORD_MIN} from './coordinates/constants'
 
 export const PRECISION = 10000
-export const CRAFT_ENERGY_DIVISOR = 150000
+export const MASS_UNITS_PER_TONNE = 10
+export const MASS_STAT_SCALE = 100
+export const CRAFT_ENERGY_DIVISOR = 1500
 
-export const WAREHOUSE_Z = 500
+export const PLANETARY_STRUCTURE_Z = 0
 
 export const CONTAINER_Z = 300
 
 export const TRAVEL_MAX_DURATION = 86400
 
+export const BASE_HAUL_PENALTY_MILLI = 300
+export const HAULER_EFFICIENCY_DENOM = 10000
+
 export const MIN_ORBITAL_ALTITUDE = 800
 export const MAX_ORBITAL_ALTITUDE = 3000
 
-export const BASE_ORBITAL_MASS = 100000
+export const BASE_ORBITAL_MASS = 1000
+
+export const MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE = 100
+export const MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL = 200
+
+export interface ClusterSlotType {
+    hub: UInt64Type
+    gx: number
+    gy: number
+}
 
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
     hullmass?: UInt32
-    energy?: UInt16
+    energy?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    loader_lanes?: ServerContract.Types.loader_lane[]
     hauler?: ServerContract.Types.hauler_stats
     capacity?: UInt32
 }
@@ -48,12 +63,39 @@ export enum TaskType {
     GATHER = 5,
     WARP = 6,
     CRAFT = 7,
-    DEPLOY = 8,
-    WRAP = 9,
+    TRANSIT = 9,
     UNWRAP = 10,
     UNDEPLOY = 11,
-    WRAP_ENTITY = 12,
+    LAUNCH = 12,
     DEMOLISH = 13,
+    BUILDPLOT = 15,
+    CHARGE = 16,
+    UPGRADE = 17,
+    SHUTTLE = 18,
+    REFIT = 19,
+    CONTRIBUTE = 20,
+    /** @deprecated Renamed to CIVIC_DEPOSIT. */
+    DEPOT_STORE = 21,
+    /** @deprecated Renamed to CIVIC_WITHDRAW. */
+    DEPOT_TAKE = 22,
+    CIVIC_DEPOSIT = 21,
+    CIVIC_WITHDRAW = 22,
+}
+
+export enum RefitOp {
+    ADD = 0,
+    REMOVE = 1,
+    SWAP = 2,
+}
+
+export enum HoldKind {
+    PULL = 1,
+    PUSH = 2,
+    GATHER = 3,
+    BUILD = 4,
+    FLIGHT = 5,
+    UPGRADE = 6,
+    SOURCE = 7,
 }
 
 export enum LocationType {
@@ -70,14 +112,6 @@ export enum TaskCancelable {
     ALWAYS = 2,
 }
 
-export const EntityType = {
-    SHIP: Name.from('ship'),
-    WAREHOUSE: Name.from('warehouse'),
-    CONTAINER: Name.from('container'),
-} as const
-
-export type EntityTypeName = (typeof EntityType)[keyof typeof EntityType]
-
 export type CoordinatesType =
     | Coordinates
     | ServerContract.Types.coordinates
@@ -100,13 +134,30 @@ export class Coordinates extends ServerContract.Types.coordinates {
 
 export function coordsToLocationId(coords: CoordinatesType): UInt64 {
     const c = Coordinates.from(coords)
-    const mask = BigInt(0xffffffff)
-    const x = BigInt(c.x.toNumber()) & mask
-    const y = BigInt(c.y.toNumber()) & mask
-    const id = (x << BigInt(32)) | y
+    const x = BigInt(c.x.toString())
+    const y = BigInt(c.y.toString())
+    if (
+        x < BigInt(COORD_MIN) ||
+        x > BigInt(COORD_MAX) ||
+        y < BigInt(COORD_MIN) ||
+        y > BigInt(COORD_MAX)
+    ) {
+        throw new Error('coordinate out of int32 bounds')
+    }
+    const offset = BigInt(2147483648)
+    const id = ((x + offset) << BigInt(32)) | (y + offset)
     return UInt64.from(id)
 }
 
+export function locationIdToCoords(id: UInt64Type): {x: number; y: number} {
+    const value = BigInt(UInt64.from(id).toString())
+    const offset = BigInt(2147483648)
+    return {
+        x: Number((value >> BigInt(32)) - offset),
+        y: Number((value & BigInt('0xffffffff')) - offset),
+    }
+}
+
 export interface Distance {
     origin: ServerContract.ActionParams.Type.coordinates
     destination: ServerContract.ActionParams.Type.coordinates
@@ -123,11 +174,15 @@ export type ModuleType =
     | 'loader'
     | 'warp'
     | 'crafter'
+    | 'builder'
     | 'launcher'
     | 'storage'
     | 'hauler'
+    | 'battery'
+    | 'catcher'
+    | 'aux'
 
-export const TIER_ADJECTIVES: Record<number, string> = {
+export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',
     2: 'Dense',
     3: 'Pure',
@@ -140,6 +195,9 @@ export const TIER_ADJECTIVES: Record<number, string> = {
     10: 'Ascendant',
 }
 
+export const COMPONENT_TIER_PREFIXES: Record<number, string> = {}
+export const MODULE_TIER_PREFIXES: Record<number, string> = {}
+
 export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
     ore: 'Ore',
     crystal: 'Crystal',
@@ -165,5 +223,5 @@ export function formatTier(tier: number): string {
 }
 
 export function tierAdjective(tier: number): string {
-    return TIER_ADJECTIVES[tier] ?? `T${tier}`
+    return RESOURCE_TIER_ADJECTIVES[tier] ?? `T${tier}`
 }

package/src/utils/cargo.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, test} from 'bun:test'
+import {cargoRef} from './cargo'
+
+describe('cargoRef', () => {
+    test('forwards entity_id when provided', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n, modules: [], entity_id: 42n})
+        expect(ref.entity_id).toBe(42n)
+    })
+
+    test('omits entity_id when absent', () => {
+        const ref = cargoRef({item_id: 10201, stats: 196849n})
+        expect(ref.entity_id).toBeUndefined()
+    })
+})

package/src/utils/cargo.ts

@@ -4,11 +4,13 @@ export function cargoRef(src: {
     item_id: number
     stats: bigint | number
     modules?: ServerContract.Types.module_entry[]
+    entity_id?: bigint | number
 }): ServerContract.ActionParams.Type.cargo_ref {
     return {
         item_id: src.item_id,
         stats: src.stats,
         modules: src.modules ?? [],
+        entity_id: src.entity_id,
     }
 }
 

package/src/utils/display-name.ts

@@ -0,0 +1,70 @@
+export interface DisplayNameResult {
+    valid: boolean
+    reason?: string
+    name: string
+}
+
+const MAX_DISPLAY_NAME_BYTES = 32
+const ASCII_SPACE = 0x20
+const ZERO_WIDTH_CODE_POINTS = new Set([0x200b, 0x200c, 0x200d, 0x2060, 0xfeff])
+const textEncoder = new TextEncoder()
+
+function isControlCharacter(codePoint: number): boolean {
+    return codePoint <= 0x1f || codePoint === 0x7f || (codePoint >= 0x80 && codePoint <= 0x9f)
+}
+
+function isLoneSurrogate(codePoint: number): boolean {
+    return codePoint >= 0xd800 && codePoint <= 0xdfff
+}
+
+function isBidiControl(codePoint: number): boolean {
+    return (
+        (codePoint >= 0x202a && codePoint <= 0x202e) || (codePoint >= 0x2066 && codePoint <= 0x2069)
+    )
+}
+
+function isInvalidDisplayNameCodePoint(codePoint: number): boolean {
+    return (
+        isControlCharacter(codePoint) ||
+        isLoneSurrogate(codePoint) ||
+        ZERO_WIDTH_CODE_POINTS.has(codePoint) ||
+        isBidiControl(codePoint)
+    )
+}
+
+export function normalizeDisplayName(input: string): string {
+    let start = 0
+    let end = input.length
+
+    while (start < end && input.charCodeAt(start) === ASCII_SPACE) start++
+    while (end > start && input.charCodeAt(end - 1) === ASCII_SPACE) end--
+
+    return input.slice(start, end)
+}
+
+export interface ValidateDisplayNameOptions {
+    allowEmpty?: boolean
+}
+
+export function validateDisplayName(
+    input: string,
+    opts: ValidateDisplayNameOptions = {}
+): DisplayNameResult {
+    const name = normalizeDisplayName(input)
+
+    if (name.length === 0) {
+        return opts.allowEmpty ? {valid: true, name} : {valid: false, reason: 'empty', name}
+    }
+    if (textEncoder.encode(name).length > MAX_DISPLAY_NAME_BYTES) {
+        return {valid: false, reason: 'too_long', name}
+    }
+
+    for (const character of name) {
+        const codePoint = character.codePointAt(0)!
+        if (isInvalidDisplayNameCodePoint(codePoint)) {
+            return {valid: false, reason: 'invalid_char', name}
+        }
+    }
+
+    return {valid: true, name}
+}

package/src/utils/hash.ts

@@ -1,11 +1,31 @@
 import {Bytes, Checksum256, type Checksum256Type, Checksum512} from '@wharfkit/antelope'
 
+type NativeHasher = new (
+    algorithm: 'sha256' | 'sha512'
+) => {
+    update(data: Uint8Array): {digest(): Uint8Array}
+}
+
+// antelope hashes through pure-JS hash.js; bun's native hasher is ~30x faster and byte-identical.
+const nativeHasher: NativeHasher | undefined = (globalThis as {Bun?: {CryptoHasher?: NativeHasher}})
+    .Bun?.CryptoHasher
+
+function digest(algorithm: 'sha256' | 'sha512', bytes: Bytes): Uint8Array | undefined {
+    return nativeHasher ? new nativeHasher(algorithm).update(bytes.array).digest() : undefined
+}
+
 export function hash(seed: Checksum256Type, string: string): Checksum256 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
-    return Checksum256.hash(bytes)
+    const native = digest('sha256', bytes)
+    return native ? new Checksum256(native) : Checksum256.hash(bytes)
 }
 
 export function hash512(seed: Checksum256Type, string: string): Checksum512 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
-    return Checksum512.hash(bytes)
+    const native = digest('sha512', bytes)
+    return native ? new Checksum512(native) : Checksum512.hash(bytes)
+}
+
+export function uint16(hash: Checksum512, offset: number): number {
+    return (hash.array[offset] << 8) | hash.array[offset + 1]
 }

package/src/utils/system.ts

@@ -1,8 +1,9 @@
 import {Checksum256, type Checksum256Type, type Checksum512, UInt8} from '@wharfkit/antelope'
-import {hash512} from './hash'
+import {hash512, uint16} from './hash'
 import {Coordinates, type CoordinatesType, LocationType} from '../types'
 import {ServerContract} from '../contracts'
 import {deriveLocationSize} from '../derivation/location-size'
+import {wormholeAt} from '../derivation/wormhole'
 import syllables from '../data/syllables.json'
 import nebulaAdjectives from '../data/nebula-adjectives.json'
 import nebulaNouns from '../data/nebula-nouns.json'
@@ -46,10 +47,6 @@ export function getLocationTypeName(type: LocationType): string {
     }
 }
 
-function uint16(hash: Checksum512, offset: number): number {
-    return (hash.array[offset] << 8) | hash.array[offset + 1]
-}
-
 function generatePlanetName(hashResult: Checksum512): string {
     const syllableCount = 2 + (hashResult.array[0] % 2)
     const name: string[] = []
@@ -110,6 +107,16 @@ export function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesTyp
     return getLocationType(gameSeed, coordinates) !== LocationType.EMPTY
 }
 
+export function getLocationKind(
+    gameSeed: Checksum256Type,
+    x: number,
+    y: number
+): 'wormhole' | 'system' | 'empty' {
+    if (wormholeAt(gameSeed, x, y)) return 'wormhole'
+    if (hasSystem(gameSeed, {x, y})) return 'system'
+    return 'empty'
+}
+
 export function deriveLocationStatic(
     gameSeed: Checksum256Type,
     coordinates: CoordinatesType
@@ -150,6 +157,18 @@ export function deriveLocationStatic(
     return loc
 }
 
+export function isLocationBuildable(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): boolean {
+    const type = getLocationType(gameSeed, coordinates)
+    return (
+        type === LocationType.ASTEROID ||
+        type === LocationType.NEBULA ||
+        type === LocationType.ICE_FIELD
+    )
+}
+
 export function deriveLocation(
     gameSeed: Checksum256Type,
     coordinates: CoordinatesType

package/src/capabilities/loading.ts

@@ -1,8 +0,0 @@
-import {UInt32, type UInt64} from '@wharfkit/antelope'
-import type {LoaderCapability} from '../types/capabilities'
-
-export function calcLoadDuration(entity: LoaderCapability, cargoMass: UInt64): UInt32 {
-    const totalThrust = entity.loaders.thrust.toNumber() * entity.loaders.quantity.toNumber()
-    if (totalThrust === 0) return UInt32.from(0)
-    return UInt32.from(Math.ceil(Number(cargoMass) / totalThrust))
-}

package/src/entities/container.ts

@@ -1,123 +0,0 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import type {CoordinatesType} from '../types'
-import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
-import {Location} from './location'
-import {ScheduleAccessor} from '../scheduling/accessor'
-import * as schedule from '../scheduling/schedule'
-
-export interface ContainerStateInput {
-    id: UInt64Type
-    owner: string
-    name: string
-    coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass: number
-    capacity: number
-    cargomass?: number
-    cargo?: ServerContract.Types.cargo_item[]
-    schedule?: ServerContract.Types.schedule
-}
-
-export class Container extends ServerContract.Types.entity_info {
-    private _sched?: ScheduleAccessor
-
-    get name(): string {
-        return this.entity_name
-    }
-
-    get entityClass(): 'mobile' {
-        return 'mobile'
-    }
-
-    get canUndeploy(): boolean {
-        return true
-    }
-
-    get sched(): ScheduleAccessor {
-        this._sched ??= new ScheduleAccessor(this)
-        return this._sched
-    }
-
-    get isIdle(): boolean {
-        return this.is_idle
-    }
-
-    interpolatedPositionAt(now: Date): FloatPosition {
-        const taskIndex = this.sched.currentTaskIndex(now)
-        const progress = this.sched.currentTaskProgressFloat(now)
-        return getInterpolatedPosition(this, taskIndex, progress)
-    }
-
-    isLoading(now: Date): boolean {
-        return schedule.isLoading(this, now)
-    }
-
-    isUnloading(now: Date): boolean {
-        return schedule.isUnloading(this, now)
-    }
-
-    get location(): Location {
-        return Location.from(this.coordinates)
-    }
-
-    get totalMass(): UInt64 {
-        return UInt64.from(this.hullmass ?? 0).adding(this.cargomass)
-    }
-
-    get maxCapacity(): UInt64 {
-        return UInt64.from(this.capacity)
-    }
-
-    get availableCapacity(): UInt64 {
-        const cargo = UInt64.from(this.cargomass)
-        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
-    }
-
-    hasSpace(additionalMass: UInt64): boolean {
-        return UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity)
-    }
-
-    get isFull(): boolean {
-        return UInt64.from(this.cargomass).gte(this.maxCapacity)
-    }
-
-    get orbitalAltitude(): number {
-        return this.coordinates.z?.toNumber() || 0
-    }
-}
-
-export function computeContainerCapabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const density = stats.density
-    const strength = stats.strength
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 25000 + 75 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2997
-    const capacity = Math.floor(1000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 20000 + 50 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2500
-    const capacity = Math.floor(1500000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}