@shipload/sdk 1.0.0-next.31 → 1.0.0-next.33

package/src/managers/nft.ts

@@ -1,12 +1,26 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import type {ServerContract} from '../contracts'
+import type {PlatformContract, ServerContract} from '../contracts'
 
 export interface NftConfigForItem {
     templateId: number
     schemaName: string
 }
 
+export interface WrapDeposit {
+    cost: bigint
+    refund: bigint
+    feePct: number
+    symbol: string
+    precision: number
+    tokenContract: string
+}
+
+export function resolveLockedAmount(cost: bigint, feePctBasisPoints: number): bigint {
+    const fee = (cost * BigInt(feePctBasisPoints)) / 10_000n
+    return cost - fee
+}
+
 export class NftManager extends BaseManager {
     private cache = new Map<string, NftConfigForItem | null>()
 
@@ -25,4 +39,32 @@ export class NftManager extends BaseManager {
         this.cache.set(key, result)
         return result ?? undefined
     }
+
+    async getWrapDeposit(itemType: number, tier: number): Promise<WrapDeposit | null> {
+        const key = UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
+        const costRow = (await this.server.table('wrapcost').get(key)) as
+            | ServerContract.Types.wrapcost_row
+            | undefined
+        const cost = costRow ? BigInt(costRow.amount.toString()) : 0n
+        if (cost === 0n) return null
+
+        const cfg = (await this.server.table('wrapconfig').get()) as
+            | ServerContract.Types.wrapconfig_row
+            | undefined
+        const feePctBasisPoints = cfg ? Number(cfg.fee_pct) : 0
+
+        const depositCfg = (await this.platform.table('depositcfg').get()) as
+            | PlatformContract.Types.depositcfg_row
+            | undefined
+        if (!depositCfg) return null
+
+        return {
+            cost,
+            refund: resolveLockedAmount(cost, feePctBasisPoints),
+            feePct: feePctBasisPoints / 100,
+            symbol: depositCfg.token_symbol.code.toString(),
+            precision: depositCfg.token_symbol.precision,
+            tokenContract: depositCfg.token_contract.toString(),
+        }
+    }
 }

package/src/managers/plot.ts

@@ -79,13 +79,10 @@ export class PlotManager extends BaseManager {
         }
 
         let state: BuildableTarget['state']
-        const taskType = activeTask?.type.toNumber()
         if (scheduledBuild?.hasStarted) {
             state = 'finalizing'
         } else if (scheduledBuild) {
             state = 'scheduled'
-        } else if (taskType === TaskType.CLAIMPLOT) {
-            state = 'initializing'
         } else if (progress.isComplete) {
             state = 'ready'
         } else {

package/src/nft/description.ts

@@ -57,7 +57,7 @@ export const computeGathererDrain = (con: number): number =>
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
-export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
+export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla, 10000)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 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))

package/src/scheduling/energy.ts

@@ -20,12 +20,11 @@ export function energyAtTime(entity: Projectable, now: Date): number {
 
     for (const {task, startsAt} of ordered) {
         const duration = task.duration.toNumber()
-        const isReserved = task.type.toNumber() === TaskType.RESERVED
         const elapsed = Math.min(
             Math.max(0, Math.floor((nowMs - startsAt.getTime()) / 1000)),
             duration
         )
-        const complete = !isReserved && elapsed >= duration
+        const complete = elapsed >= duration
         const inProgress = !complete && elapsed > 0 && elapsed < duration
 
         if (!complete && !inProgress) continue

package/src/scheduling/idle-resolve.ts

@@ -0,0 +1,44 @@
+import type {Action, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {ActionsManager} from '../managers/actions'
+import {hasResolvable, type ScheduleData} from './schedule'
+
+type EntityInfo = ServerContract.Types.entity_info
+
+export type CounterpartLookup = (entityId: UInt64) => EntityInfo | undefined
+
+export type IdleResolveTarget = ScheduleData & {id: UInt64}
+
+// A hold's driving task lives on its counterpart, so a hold resolves the counterpart, never the blocker.
+export function composeIdleResolve(
+    blocker: IdleResolveTarget,
+    action: Action,
+    actions: ActionsManager,
+    now: Date,
+    lookupCounterpart?: CounterpartLookup
+): Action[] {
+    const ids: UInt64[] = []
+    const seen = new Set<string>()
+
+    const add = (id: UInt64) => {
+        const key = id.toString()
+        if (seen.has(key)) return
+        seen.add(key)
+        ids.push(id)
+    }
+
+    if (hasResolvable(blocker, now)) {
+        add(blocker.id)
+    }
+
+    for (const hold of blocker.holds ?? []) {
+        const counterpartId = hold.counterpart.entity_id
+        if (lookupCounterpart) {
+            const counterpart = lookupCounterpart(counterpartId)
+            if (!counterpart || !hasResolvable(counterpart, now)) continue
+        }
+        add(counterpartId)
+    }
+
+    return [...ids.map((id) => actions.resolve(id)), action]
+}

package/src/scheduling/lane-core.ts

@@ -1,5 +1,5 @@
 import type {ServerContract} from '../contracts'
-import {TaskType} from '../types'
+import type {TaskType} from '../types'
 
 type Schedule = ServerContract.Types.schedule
 type Task = ServerContract.Types.task
@@ -27,7 +27,6 @@ export function laneRemaining(schedule: Schedule, now: Date): number {
 
 export function laneComplete(schedule: Schedule, now: Date): boolean {
     if (schedule.tasks.length === 0) return false
-    if (schedule.tasks.some((t) => t.type.toNumber() === TaskType.RESERVED)) return false
     return laneRemaining(schedule, now) === 0
 }
 
@@ -87,7 +86,6 @@ export function laneTaskRemaining(schedule: Schedule, index: number, now: Date):
 
 export function laneTaskComplete(schedule: Schedule, index: number, now: Date): boolean {
     if (index < 0 || index >= schedule.tasks.length) return false
-    if (schedule.tasks[index].type.toNumber() === TaskType.RESERVED) return false
     const taskDuration = schedule.tasks[index].duration.toNumber()
     return laneTaskElapsed(schedule, index, now) >= taskDuration
 }

package/src/scheduling/projection.ts

@@ -442,12 +442,11 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
 
     for (const {task, startsAt} of ordered) {
         const duration = task.duration.toNumber()
-        const isReserved = task.type.toNumber() === TaskType.RESERVED
         const elapsed = Math.min(
             Math.max(0, Math.floor((nowMs - startsAt.getTime()) / 1000)),
             duration
         )
-        const taskComplete = !isReserved && elapsed >= duration
+        const taskComplete = elapsed >= duration
         const taskInProgress = elapsed > 0 && elapsed < duration
 
         if (!taskComplete && !taskInProgress) {

package/src/scheduling/schedule.ts

@@ -5,12 +5,14 @@ import * as core from './lane-core'
 type Schedule = ServerContract.Types.schedule
 type Task = ServerContract.Types.task
 type Lane = ServerContract.Types.lane
+type Hold = ServerContract.Types.hold
 
 export const LANE_MOBILITY = 0
 export const LANE_BARRIER = 255
 
 export interface ScheduleData {
     lanes?: Lane[]
+    holds?: Hold[]
 }
 
 export interface LaneView {
@@ -52,11 +54,17 @@ export function hasSchedule(entity: ScheduleData): boolean {
     return lanes.some((l) => l.schedule.tasks.length > 0)
 }
 
+export function hasHolds(entity: ScheduleData): boolean {
+    const holds = entity.holds
+    return !!holds && holds.length > 0
+}
+
 export function isIdle(entity: ScheduleData): boolean {
-    return !hasSchedule(entity)
+    return !hasSchedule(entity) && !hasHolds(entity)
 }
 
 export function isEntityIdle(entity: ScheduleData, now: Date): boolean {
+    if (hasHolds(entity)) return false
     const lanes = entity.lanes
     if (!lanes) return true
     return lanes.every((l) => core.currentTaskIndexForLane(l.schedule, now) < 0)
@@ -106,13 +114,7 @@ export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
     let hasAnyTask = false
     let remaining = 0
     for (const l of lanes) {
-        const tasks = l.schedule.tasks
-        if (tasks.length > 0) {
-            hasAnyTask = true
-            for (const t of tasks) {
-                if (t.type.toNumber() === TaskType.RESERVED) return false
-            }
-        }
+        if (l.schedule.tasks.length > 0) hasAnyTask = true
         remaining = Math.max(remaining, core.laneRemaining(l.schedule, now))
     }
     if (!hasAnyTask) return false
@@ -186,7 +188,6 @@ export function resolveOrder(entity: ScheduleData, now: Date): ResolvedEvent[] {
             const task = l.schedule.tasks[i]
             endSec += task.duration.toNumber()
             const completesAt = new Date(startedMs + endSec * 1000)
-            if (task.type.toNumber() === TaskType.RESERVED) break
             if (completesAt.getTime() > now.getTime()) break
             events.push({laneKey, taskIndex: i, task, completesAt})
         }

package/src/subscriptions/mappers.ts

@@ -19,5 +19,7 @@ export function parseWireEntity(raw: WireEntity): ServerContract.Types.entity_in
     }
     delete shaped.name
 
+    if (shaped.holds === undefined) shaped.holds = []
+
     return ServerContract.Types.entity_info.from(shaped)
 }

package/src/types.ts

@@ -23,7 +23,7 @@ export const MAX_ORBITAL_ALTITUDE = 3000
 export const BASE_ORBITAL_MASS = 100000
 
 export const MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE = 100
-export const MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL = 300
+export const MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL = 200
 
 export interface ShipLike {
     coordinates: ServerContract.Types.coordinates
@@ -56,7 +56,13 @@ export enum TaskType {
     DEMOLISH = 13,
     CLAIMPLOT = 14,
     BUILDPLOT = 15,
-    RESERVED = 16,
+}
+
+export enum HoldKind {
+    PULL = 1,
+    PUSH = 2,
+    GATHER = 3,
+    BUILD = 4,
 }
 
 export enum LocationType {