@shipload/sdk 0.7.1 → 1.0.0-next.0

package/package.json

@@ -1,25 +1,27 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "0.7.1",
+    "version": "1.0.0-next.0",
     "homepage": "https://github.com/shipload/sdk",
     "license": "MIT",
     "main": "lib/shipload.js",
     "module": "lib/shipload.m.js",
     "types": "lib/shipload.d.ts",
-    "unpkg": "lib/shipload.bundle.js",
     "sideEffects": false,
     "files": [
         "lib/*",
         "src/*"
     ],
     "scripts": {
-        "prepare": "make"
+        "prepare": "make",
+        "check": "tsc --noEmit",
+        "build": "make build",
+        "test": "make test"
     },
     "dependencies": {
-        "@wharfkit/antelope": "^1.0.2",
-        "@wharfkit/contract": "^1.1.5",
-        "@wharfkit/session": "^1.3.1",
+        "@wharfkit/antelope": "1.2.0",
+        "@wharfkit/common": "1.5.0",
+        "@wharfkit/contract": "1.2.1",
         "tslib": "^2.1.0"
     },
     "devDependencies": {
@@ -30,34 +32,23 @@
         "@rollup/plugin-json": "^4.1.0",
         "@rollup/plugin-node-resolve": "^14.1.0",
         "@rollup/plugin-replace": "^5.0.1",
-        "@rollup/plugin-typescript": "^10.0.1",
+        "@rollup/plugin-typescript": "^12.1.0",
         "@rollup/plugin-virtual": "^2.0.3",
+        "@types/bun": "latest",
         "@types/chai": "^4.3.1",
-        "@types/mocha": "^9.0.0",
         "@types/node": "^18.7.18",
-        "@typescript-eslint/eslint-plugin": "^5.20.0",
-        "@typescript-eslint/parser": "^5.20.0",
         "@wharfkit/mock-data": "^1.3.0",
         "@wharfkit/wallet-plugin-privatekey": "^1.1.0",
         "chai": "^4.3.4",
-        "eslint": "^8.13.0",
-        "eslint-config-prettier": "^8.1.0",
-        "eslint-plugin-prettier": "^4.0.0",
         "gh-pages": "^4.0.0",
-        "mocha": "^10.0.0",
         "node-fetch": "^2.6.1",
-        "nyc": "^15.1.0",
         "onchange": "^7.1.0",
-        "prettier": "^2.2.1",
         "rollup": "^2.70.2",
         "rollup-plugin-cleanup": "^3.2.1",
         "rollup-plugin-dts": "^4.2.1",
         "rollup-plugin-terser": "^7.0.2",
-        "ts-node": "^10.9.1",
-        "tsconfig-paths": "^4.1.1",
         "typedoc": "^0.23.14",
         "typedoc-plugin-mermaid": "^1.10.0",
-        "typescript": "^4.1.2",
-        "yarn-deduplicate": "^6.0.2"
+        "typescript": "^5.4.0"
     }
 }

package/src/capabilities/crafting.ts

@@ -0,0 +1,22 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {CRAFT_ENERGY_DIVISOR} from '../types'
+import type {EntityCapabilities} from '../types/capabilities'
+import type {ServerContract} from '../contracts'
+
+export interface CrafterCapability {
+    crafter: ServerContract.Types.crafter_stats
+}
+
+export function capsHasCrafter(caps: EntityCapabilities): boolean {
+    return caps.crafter !== undefined
+}
+
+export function calc_craft_duration(speed: number, totalInputMass: number): UInt32 {
+    const duration = Math.floor(totalInputMass / speed)
+    return UInt32.from(Math.max(duration, 1))
+}
+
+export function calc_craft_energy(drain: number, totalInputMass: number): UInt16 {
+    const raw = Math.floor((totalInputMass * drain) / CRAFT_ENERGY_DIVISOR)
+    return UInt16.from(Math.min(raw, 65535))
+}

package/src/capabilities/gathering.ts

@@ -0,0 +1,36 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+
+const GATHER_TIME_SCALE = 100
+const DEPTH_PENALTY_DIVISOR = 5000
+const SPEED_TIME_SCALE = 300
+
+export function calc_gather_duration(
+    gatherer: ServerContract.Types.gatherer_stats,
+    itemMass: number,
+    quantity: number,
+    stratum: number,
+    richness: number
+): UInt32 {
+    const yieldValue = gatherer.yield.toNumber()
+    const speed = gatherer.speed.toNumber()
+
+    if (yieldValue === 0 || speed === 0 || richness === 0) return UInt32.from(0)
+
+    const massFactor = Math.sqrt(itemMass)
+    const depthPenalty = 1 + stratum / DEPTH_PENALTY_DIVISOR
+    const richnessMul = richness / 1000
+    const gatherTime =
+        (quantity * massFactor * GATHER_TIME_SCALE * depthPenalty) / (yieldValue * richnessMul)
+    const speedTime = SPEED_TIME_SCALE * Math.log(1 + stratum / speed)
+    return UInt32.from(Math.floor(gatherTime + speedTime))
+}
+
+export function calc_gather_energy(
+    gatherer: ServerContract.Types.gatherer_stats,
+    duration: number
+): UInt16 {
+    const energy = Math.floor((duration * gatherer.drain.toNumber()) / PRECISION)
+    return UInt16.from(energy)
+}

package/src/capabilities/guards.ts

@@ -0,0 +1,38 @@
+import type {
+    EnergyCapability,
+    GathererCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from '../types/capabilities'
+import type {Entity} from '../types/entity'
+
+export function canMove(e: Entity): e is Entity & MovementCapability & EnergyCapability {
+    return 'engines' in e && 'generator' in e && 'energy' in e
+}
+
+export function hasEnergy(e: Entity): e is Entity & EnergyCapability {
+    return 'energy' in e
+}
+
+export function hasStorage(e: Entity): e is Entity & StorageCapability {
+    return 'capacity' in e && 'cargo' in e
+}
+
+export function hasLoaders(e: Entity): e is Entity & LoaderCapability {
+    return 'loaders' in e && e.loaders !== undefined
+}
+
+export function hasMass(e: Entity): e is Entity & MassCapability {
+    return 'hullmass' in e
+}
+
+export function hasSchedule(e: Entity): e is Entity & ScheduleCapability {
+    return 'schedule' in e
+}
+
+export function hasGatherer(e: Entity): e is Entity & GathererCapability {
+    return 'gatherer' in e && e.gatherer !== undefined
+}

package/src/capabilities/hauling.ts

@@ -0,0 +1,22 @@
+const BASE_HAUL_PENALTY_MILLI = 300
+const HAULER_EFFICIENCY_DENOM = 10000
+const PRECISION = 10000
+
+export function computeHaulPenalty(
+    totalThrust: number,
+    haulCount: number,
+    avgEfficiency: number
+): number {
+    if (haulCount === 0) return totalThrust
+    const penaltyMilli =
+        1000 +
+        Math.floor(
+            (haulCount * BASE_HAUL_PENALTY_MILLI * (HAULER_EFFICIENCY_DENOM - avgEfficiency)) /
+                HAULER_EFFICIENCY_DENOM
+        )
+    return Math.floor((totalThrust * 1000) / penaltyMilli)
+}
+
+export function computeHaulerDrain(distance: number, drain: number, haulCount: number): number {
+    return Math.floor(distance / PRECISION) * drain * haulCount
+}

package/src/capabilities/index.ts

@@ -0,0 +1,8 @@
+export * from './guards'
+export * from './movement'
+export * from './storage'
+export * from './loading'
+export * from './gathering'
+export * from './crafting'
+export * from './modules'
+export * from './hauling'

package/src/capabilities/loading.ts

@@ -0,0 +1,8 @@
+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/capabilities/modules.ts

@@ -0,0 +1,86 @@
+import {
+    ITEM_CRAFTER_T1,
+    ITEM_ENGINE_T1,
+    ITEM_GATHERER_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
+    ITEM_LOADER_T1,
+    ITEM_STORAGE_T1,
+} from '../data/item-ids'
+
+export const MODULE_ANY = 0
+export const MODULE_ENGINE = 1
+export const MODULE_GENERATOR = 2
+export const MODULE_GATHERER = 3
+export const MODULE_LOADER = 4
+export const MODULE_WARP = 5
+export const MODULE_CRAFTER = 6
+export const MODULE_LAUNCHER = 7
+export const MODULE_STORAGE = 8
+export const MODULE_HAULER = 9
+
+export interface PackedModule {
+    itemId: number
+    stats: bigint
+}
+
+export interface ModuleEntry {
+    type: number
+    installed?: PackedModule
+}
+
+export function moduleAccepts(slotType: number, moduleType: number): boolean {
+    return slotType === MODULE_ANY || slotType === moduleType
+}
+
+export function getModuleCapabilityType(itemId: number): number {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return MODULE_ENGINE
+        case ITEM_GENERATOR_T1:
+            return MODULE_GENERATOR
+        case ITEM_GATHERER_T1:
+            return MODULE_GATHERER
+        case ITEM_LOADER_T1:
+            return MODULE_LOADER
+        case ITEM_CRAFTER_T1:
+            return MODULE_CRAFTER
+        case ITEM_STORAGE_T1:
+            return MODULE_STORAGE
+        case ITEM_HAULER_T1:
+            return MODULE_HAULER
+        default:
+            return 0xff
+    }
+}
+
+export function isModuleItem(itemId: number): boolean {
+    return getModuleCapabilityType(itemId) !== 0xff
+}
+
+export function moduleSlotTypeToCode(slotType: string): number {
+    switch (slotType) {
+        case 'any':
+            return MODULE_ANY
+        case 'engine':
+            return MODULE_ENGINE
+        case 'generator':
+            return MODULE_GENERATOR
+        case 'gatherer':
+            return MODULE_GATHERER
+        case 'loader':
+            return MODULE_LOADER
+        case 'warp':
+            return MODULE_WARP
+        case 'crafter':
+            return MODULE_CRAFTER
+        case 'launcher':
+            return MODULE_LAUNCHER
+        case 'storage':
+            return MODULE_STORAGE
+        case 'hauler':
+            return MODULE_HAULER
+        default:
+            return MODULE_ANY
+    }
+}

package/src/capabilities/movement.ts

@@ -0,0 +1,29 @@
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import type {EnergyCapability, MovementCapability} from '../types/capabilities'
+import {PRECISION} from '../types'
+
+export function maxTravelDistance(entity: MovementCapability): UInt32 {
+    return UInt32.from(entity.generator.capacity)
+        .dividing(entity.engines.drain)
+        .multiplying(PRECISION)
+}
+
+export function calcEnergyUsage(entity: MovementCapability, distance: UInt64): UInt64 {
+    return distance.dividing(PRECISION).multiplying(entity.engines.drain)
+}
+
+export function hasEnergyForDistance(
+    entity: MovementCapability & EnergyCapability,
+    distance: UInt64
+): boolean {
+    const usage = calcEnergyUsage(entity, distance)
+    return UInt64.from(entity.energy).gte(usage)
+}
+
+export function energyPercent(entity: MovementCapability & EnergyCapability): number {
+    return (Number(entity.energy) / Number(entity.generator.capacity)) * 100
+}
+
+export function needsRecharge(entity: MovementCapability & EnergyCapability): boolean {
+    return UInt64.from(entity.energy).lt(entity.generator.capacity)
+}

package/src/capabilities/storage.ts

@@ -0,0 +1,159 @@
+import {UInt16, UInt32, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {StorageCapability} from '../types/capabilities'
+import {getItem} from '../data/catalog'
+import {INSUFFICIENT_ITEM_QUANTITY} from '../errors'
+
+export interface HasCargo {
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface HasCapacity {
+    capacity: UInt32
+}
+
+export interface HasCargomass {
+    cargomass: UInt32
+}
+
+interface MassInput {
+    item_id: UInt16
+    quantity: UInt32
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function calcCargoItemMass(item: MassInput): UInt64 {
+    const itemDef = getItem(item.item_id)
+    let mass = UInt64.from(itemDef.mass).multiplying(item.quantity)
+
+    for (const mod of item.modules) {
+        if (mod.installed) {
+            const modDef = getItem(mod.installed.item_id)
+            mass = mass.adding(UInt64.from(modDef.mass))
+        }
+    }
+
+    return mass
+}
+
+export function calcCargoMass(entity: HasCargo): UInt64 {
+    let mass = UInt64.from(0)
+    for (const item of entity.cargo) {
+        mass = mass.adding(calcCargoItemMass(item))
+    }
+    return mass
+}
+
+export function calcStacksMass(stacks: CargoStack[]): UInt64 {
+    let mass = UInt64.from(0)
+    for (const s of stacks) {
+        mass = mass.adding(calcCargoItemMass(s))
+    }
+    return mass
+}
+
+export function availableCapacity(entity: StorageCapability): UInt64 {
+    const cargoMass = calcCargoMass(entity)
+    return entity.capacity.gt(cargoMass)
+        ? UInt64.from(entity.capacity).subtracting(cargoMass)
+        : UInt64.from(0)
+}
+
+export function availableCapacityFromMass(capacity: UInt64Type, cargoMass: UInt64Type): UInt64 {
+    const cap = UInt64.from(capacity)
+    const mass = UInt64.from(cargoMass)
+    return cap.gt(mass) ? cap.subtracting(mass) : UInt64.from(0)
+}
+
+export function hasSpace(entity: StorageCapability, goodMass: UInt64, quantity: number): boolean {
+    const additional = goodMass.multiplying(quantity)
+    return availableCapacity(entity).gte(additional)
+}
+
+export function hasSpaceForMass(
+    capacity: UInt64Type,
+    currentMass: UInt64Type,
+    additionalMass: UInt64Type
+): boolean {
+    return UInt64.from(currentMass).adding(additionalMass).lte(capacity)
+}
+
+export function isFull(entity: HasCapacity & HasCargomass): boolean {
+    return UInt64.from(entity.cargomass).gte(entity.capacity)
+}
+
+export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
+    return UInt64.from(cargoMass).gte(capacity)
+}
+
+export interface CargoStack {
+    item_id: UInt16
+    quantity: UInt32
+    stats: UInt64
+    modules: ServerContract.Types.module_entry[]
+}
+
+export function cargoItemToStack(item: ServerContract.Types.cargo_item): CargoStack {
+    return {
+        item_id: UInt16.from(item.item_id),
+        quantity: UInt32.from(item.quantity),
+        stats: item.stats,
+        modules: item.modules ?? [],
+    }
+}
+
+export function stackToCargoItem(stack: CargoStack): ServerContract.Types.cargo_item {
+    return ServerContract.Types.cargo_item.from({
+        item_id: stack.item_id,
+        quantity: stack.quantity,
+        stats: stack.stats,
+        modules: stack.modules,
+    })
+}
+
+function statsEquals(a: UInt64, b: UInt64): boolean {
+    return a.equals(b)
+}
+
+function stackIdentityEqual(a: CargoStack, b: CargoStack): boolean {
+    return a.item_id.equals(b.item_id) && statsEquals(a.stats, b.stats)
+}
+
+export function stackKey(s: CargoStack): string {
+    return `${s.item_id.toNumber()}:${s.stats.toString()}`
+}
+
+export function stacksEqual(a: CargoStack, b: CargoStack): boolean {
+    return stackIdentityEqual(a, b) && a.quantity.equals(b.quantity)
+}
+
+export function mergeStacks(stacks: CargoStack[], add: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, add))
+    if (idx === -1) {
+        return [...stacks, {...add}]
+    }
+    const result = stacks.slice()
+    result[idx] = {
+        ...result[idx],
+        quantity: UInt32.from(result[idx].quantity.adding(add.quantity)),
+    }
+    return result
+}
+
+export function removeFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, remove))
+    if (idx === -1) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const target = stacks[idx]
+    if (target.quantity.lt(remove.quantity)) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY)
+    }
+    const remaining = UInt32.from(target.quantity.subtracting(remove.quantity))
+    if (remaining.equals(UInt32.from(0))) {
+        return [...stacks.slice(0, idx), ...stacks.slice(idx + 1)]
+    }
+    const result = stacks.slice()
+    result[idx] = {...target, quantity: remaining}
+    return result
+}