@shipload/sdk 1.0.0-next.65 → 1.0.0-next.66

package/src/shipload.ts

@@ -1,5 +1,5 @@
 import {APIClient} from '@wharfkit/antelope'
-import {PlatformContract, ServerContract} from './contracts'
+import {FundContract, PlatformContract, ServerContract} from './contracts'
 import type {ChainDefinition} from '@wharfkit/common'
 import {ContractKit, type Contract} from '@wharfkit/contract'
 
@@ -21,6 +21,7 @@ import type {GameState} from './entities/gamestate'
 interface ShiploadOptions {
     platformContractName?: string
     serverContractName?: string
+    fundContractName?: string
     client?: APIClient
     subscriptionsUrl?: string
     atomicAssetsAccount?: string
@@ -29,13 +30,14 @@ interface ShiploadOptions {
 interface ShiploadConstructorOptions extends ShiploadOptions {
     platformContract?: Contract
     serverContract?: Contract
+    fundContract?: Contract
 }
 
 export class Shipload {
     private readonly _context: GameContext
 
     constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions) {
-        const {client, platformContract, serverContract} = constructorOptions || {}
+        const {client, platformContract, serverContract, fundContract} = constructorOptions || {}
         const apiClient = client || new APIClient({url: chain.url})
 
         const platform = platformContract
@@ -46,11 +48,14 @@ export class Shipload {
             ? serverContract
             : new ServerContract.Contract({client: apiClient})
 
+        const fund = fundContract ? fundContract : new FundContract.Contract({client: apiClient})
+
         this._context = new GameContext(
             apiClient,
             server,
             platform,
-            constructorOptions?.atomicAssetsAccount ?? 'atomicassets'
+            constructorOptions?.atomicAssetsAccount ?? 'atomicassets',
+            fund
         )
 
         if (constructorOptions?.subscriptionsUrl) {
@@ -80,10 +85,20 @@ export class Shipload {
             server = await contractKit.load(shiploadOptions.serverContractName)
         }
 
+        let fund: Contract = new FundContract.Contract({
+            client: new APIClient({url: chain.url}),
+        })
+        if (shiploadOptions?.fundContractName) {
+            const client = shiploadOptions.client || new APIClient({url: chain.url})
+            const contractKit = new ContractKit({client})
+            fund = await contractKit.load(shiploadOptions.fundContractName)
+        }
+
         return new Shipload(chain, {
             ...shiploadOptions,
             platformContract: platform,
             serverContract: server,
+            fundContract: fund,
         })
     }
 
@@ -103,6 +118,10 @@ export class Shipload {
         return this._context.platform
     }
 
+    get fund(): Contract {
+        return this._context.fund
+    }
+
     get entities(): EntitiesManager {
         return this._context.entities
     }

package/src/travel/reach.test.ts

@@ -0,0 +1,86 @@
+import {expect, test} from 'bun:test'
+import type {RouteMoverInput} from './route-simulator'
+import {computeGroupPerLegReach, computePerLegReach, type ReachStats} from './reach'
+
+// Type-level: a RouteMoverInput (webapp's mover shape) must satisfy ReachStats with no cast.
+function acceptsReachStats(_s: ReachStats): void {}
+function checkRouteMoverAssignable(m: RouteMoverInput) {
+    acceptsReachStats(m)
+}
+void checkRouteMoverAssignable
+
+test('capacity basis: reach is generator capacity over engine drain, unrounded', () => {
+    const reach = computePerLegReach({generator: {capacity: 550n}, engines: {drain: 100n}})
+    expect(reach).toBe(5.5)
+})
+
+test('capacity basis is the default when opts is omitted', () => {
+    const reach = computePerLegReach({generator: {capacity: 1000n}, engines: {drain: 250n}})
+    expect(reach).toBe(4)
+})
+
+test('current basis prefers generator capacity over current energy, matching the webapp fallback', () => {
+    const reach = computePerLegReach(
+        {generator: {capacity: 1000n}, engines: {drain: 100n}, energy: 250n},
+        {basis: 'current'}
+    )
+    expect(reach).toBe(10)
+})
+
+test('current basis falls back to current energy when there is no generator', () => {
+    const reach = computePerLegReach({engines: {drain: 100n}, energy: 350n}, {basis: 'current'})
+    expect(reach).toBe(3.5)
+})
+
+test('current basis with a lower current energy still returns the capacity-derived reach', () => {
+    const reach = computePerLegReach(
+        {generator: {capacity: 900n}, engines: {drain: 90n}, energy: 90n},
+        {basis: 'current'}
+    )
+    expect(reach).toBe(10)
+    expect(reach).not.toBe(1)
+})
+
+test('capacity basis throws for a generator-less mover', () => {
+    expect(() => computePerLegReach({engines: {drain: 100n}})).toThrow()
+})
+
+test('current basis throws when there is no current energy figure either', () => {
+    expect(() => computePerLegReach({engines: {drain: 100n}}, {basis: 'current'})).toThrow()
+})
+
+test('an empty mover list has zero reach rather than throwing', () => {
+    expect(computeGroupPerLegReach([])).toBe(0)
+})
+
+test('a group with no moving entity has zero reach', () => {
+    const reach = computeGroupPerLegReach([{generator: {capacity: 1000n}}])
+    expect(reach).toBe(0)
+})
+
+test('a RouteMoverInput-shaped mover with hasMovement: false is excluded from the group', () => {
+    const mover: ReachStats = {
+        hasMovement: false,
+        engines: {drain: 100},
+        generator: {capacity: 1000},
+    }
+    expect(computeGroupPerLegReach([mover])).toBe(0)
+})
+
+test('hasMovement defaults to true when absent', () => {
+    const mover: ReachStats = {engines: {drain: 100}, generator: {capacity: 1000}}
+    expect(computeGroupPerLegReach([mover])).toBe(10)
+})
+
+test('group reach is the minimum across movers', () => {
+    const fast: ReachStats = {engines: {drain: 100n}, generator: {capacity: 1000n}}
+    const slow: ReachStats = {engines: {drain: 100n}, generator: {capacity: 550n}}
+    expect(computeGroupPerLegReach([fast, slow])).toBe(5.5)
+})
+
+// Settled by contracts/test/server/reach-parity.test.ts: the contract truncates, so ceiling here would overclaim reach.
+test('rounding: a fractional reach is left unrounded, not ceiled', () => {
+    const reach = computePerLegReach({generator: {capacity: 550n}, engines: {drain: 100n}})
+    expect(reach).not.toBe(Math.ceil(reach))
+    expect(Math.floor(reach)).toBe(5)
+})

package/src/travel/reach.ts

@@ -1,21 +1,34 @@
 export interface ReachStats {
-    generator?: {capacity: bigint}
-    engines?: {drain: bigint}
+    generator?: {capacity: bigint | number}
+    engines?: {drain: bigint | number}
+    energy?: bigint | number
+    hasMovement?: boolean
 }
 
-export function computePerLegReach(s: ReachStats): number {
-    const capacity = s.generator?.capacity
+export interface ComputePerLegReachOptions {
+    basis?: 'capacity' | 'current'
+}
+
+export function computePerLegReach(s: ReachStats, opts: ComputePerLegReachOptions = {}): number {
+    const basis = opts.basis ?? 'capacity'
+    const energy =
+        basis === 'capacity' ? s.generator?.capacity : (s.generator?.capacity ?? s.energy)
     const drain = s.engines?.drain
-    if (capacity === undefined || drain === undefined || drain === 0n) {
+    if (energy === undefined || drain === undefined || Number(drain) === 0) {
         throw new Error('entity has no usable engine/generator (cannot compute per-leg reach)')
     }
-    return Number(capacity) / Number(drain)
+    return Number(energy) / Number(drain)
 }
 
-export function computeGroupPerLegReach(participants: ReachStats[]): number {
-    const movers = participants.filter((p) => p.engines !== undefined && p.engines.drain !== 0n)
+export function computeGroupPerLegReach(
+    participants: ReachStats[],
+    opts: ComputePerLegReachOptions = {}
+): number {
+    const movers = participants.filter(
+        (p) => (p.hasMovement ?? true) && p.engines !== undefined && Number(p.engines.drain) !== 0
+    )
     if (movers.length === 0) {
-        throw new Error('group has no moving entity (cannot compute per-leg reach)')
+        return 0
     }
-    return Math.min(...movers.map(computePerLegReach))
+    return Math.min(...movers.map((m) => computePerLegReach(m, opts)))
 }

package/src/travel/route-build.test.ts

@@ -0,0 +1,63 @@
+import {expect, test} from 'bun:test'
+import type {Coord, SystemGraph} from './route-planner'
+import {planRouteWithRetry} from './route-build'
+
+function countingGraph(opts: {
+    reachable: boolean
+    nearby: (c: Coord) => {coord: Coord; dist: number}[]
+}): {graph: SystemGraph; hasSystemCalls: () => number} {
+    let calls = 0
+    const graph: SystemGraph = {
+        hasSystem: () => {
+            calls++
+            return opts.reachable
+        },
+        nearby: opts.nearby,
+    }
+    return {graph, hasSystemCalls: () => calls}
+}
+
+test('a route found on the first attempt does not retry', () => {
+    const origin: Coord = {x: 0, y: 0}
+    const dest: Coord = {x: 3, y: 0}
+    const {graph, hasSystemCalls} = countingGraph({reachable: true, nearby: () => []})
+
+    const result = planRouteWithRetry({origin, dest, perLegReach: 5, graph})
+
+    expect(result.ok).toBe(true)
+    expect(hasSystemCalls()).toBe(1)
+})
+
+test('a no-path result widens the corridor and retries until a route is found', () => {
+    const origin: Coord = {x: 0, y: 0}
+    const dest: Coord = {x: 100, y: 0}
+    const mid: Coord = {x: 50, y: 28.4}
+    const perLegReach = 6.4
+
+    const {graph, hasSystemCalls} = countingGraph({
+        reachable: true,
+        nearby: (c) => {
+            if (c.x === origin.x && c.y === origin.y) return [{coord: mid, dist: 0}]
+            if (c.x === mid.x && c.y === mid.y) return [{coord: dest, dist: 0}]
+            return []
+        },
+    })
+
+    const result = planRouteWithRetry({origin, dest, perLegReach, graph})
+
+    expect(result.ok).toBe(true)
+    // Excluded from the default corridor, found once corridorSlack widens to perLegReach * 3.
+    expect(hasSystemCalls()).toBe(2)
+})
+
+test('a non-no-path failure returns immediately without retrying', () => {
+    const origin: Coord = {x: 0, y: 0}
+    const dest: Coord = {x: 100, y: 0}
+    const {graph, hasSystemCalls} = countingGraph({reachable: false, nearby: () => []})
+
+    const result = planRouteWithRetry({origin, dest, perLegReach: 5, graph})
+
+    expect(result.ok).toBe(false)
+    if (!result.ok) expect(result.reason).toBe('empty-destination')
+    expect(hasSystemCalls()).toBe(1)
+})

package/src/travel/route-build.ts

@@ -0,0 +1,60 @@
+import {calc_rechargetime} from './travel'
+import {MAX_LEGS, planRoute} from './route-planner'
+import type {
+    Coord,
+    RouteHeuristicCost,
+    RouteLegCost,
+    RouteResult,
+    SystemGraph,
+} from './route-planner'
+import {simulateRoute} from './route-simulator'
+import type {RouteMoverInput} from './route-simulator'
+
+export function planRouteWithRetry(input: {
+    origin: Coord
+    dest: Coord
+    perLegReach: number
+    graph: SystemGraph
+    maxLegs?: number
+    legCost?: RouteLegCost
+    heuristicCost?: RouteHeuristicCost
+}): RouteResult {
+    const args = {...input, maxLegs: input.maxLegs ?? MAX_LEGS}
+    const first = planRoute(args)
+    if (first.ok || first.reason !== 'no-path') return first
+    const widened = planRoute({...args, corridorSlack: input.perLegReach * 3})
+    if (widened.ok || widened.reason !== 'no-path') return widened
+    // The chain imposes no corridor, only per-hop reach, so exhaust the graph (nodeBudget-bounded) before declaring no-path.
+    return planRoute({...args, corridorSlack: Number.POSITIVE_INFINITY})
+}
+
+export function contractRouteLegCost(movers: readonly RouteMoverInput[]): RouteLegCost {
+    return ({from, to, isDestination}) => {
+        const sim = simulateRoute([...movers], [to], from, true)
+        const leg = sim.legs[0]
+        if (!sim.reachable || !leg) return null
+
+        let rechargeAfter = 0
+        for (const mover of movers) {
+            if (!mover.hasMovement || !mover.generator) continue
+            const cost = leg.energyCostByMover[String(mover.ref.entityId)] ?? 0
+            rechargeAfter = Math.max(
+                rechargeAfter,
+                Number(
+                    calc_rechargetime(
+                        mover.generator.capacity,
+                        Math.max(0, mover.generator.capacity - cost),
+                        mover.generator.recharge
+                    )
+                )
+            )
+        }
+
+        return leg.flightSeconds + (isDestination ? 0 : rechargeAfter)
+    }
+}
+
+export function contractRouteHeuristic(movers: readonly RouteMoverInput[]): RouteHeuristicCost {
+    return (from, dest) =>
+        simulateRoute([...movers], [dest], from, true).legs[0]?.flightSeconds ?? 0
+}

package/src/travel/travel.ts

@@ -27,6 +27,7 @@ import {
     type CargoMassInfo,
     type Distance,
     HAULER_EFFICIENCY_DENOM,
+    MASS_STAT_SCALE,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
     MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL,
@@ -253,7 +254,7 @@ export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
 }
 
 export function calc_acceleration(thrust: number, mass: number): number {
-    return (thrust / mass) * PRECISION
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
 }
 
 export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64 {

package/src/types.ts

@@ -11,7 +11,9 @@ 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 PLANETARY_STRUCTURE_Z = 0
 
@@ -25,7 +27,7 @@ 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
@@ -72,6 +74,8 @@ export enum TaskType {
     SHUTTLE = 18,
     REFIT = 19,
     CONTRIBUTE = 20,
+    DEPOT_STORE = 21,
+    DEPOT_TAKE = 22,
 }
 
 export enum RefitOp {

package/src/utils/hash.ts

@@ -1,13 +1,29 @@
 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 {