@shipload/sdk 1.0.0-next.5 → 1.0.0-next.50

package/src/managers/entities.ts

@@ -1,99 +1,60 @@
 import {Name, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
-import {Warehouse} from '../entities/warehouse'
-import {Container} from '../entities/container'
+import {Entity} from '../entities/entity'
+import type {EntityTypeName} from '../data/kind-registry'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+export type {EntityTypeName} from '../data/kind-registry'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+    async getEntity(id: UInt64Type): Promise<Entity> {
         const result = await this.server.readonly('getentity', {
-            entity_type: Name.from(type),
             entity_id: id,
         })
-        const entityInfo = result as ServerContract.Types.entity_info
-        return this.wrapEntity(entityInfo)
+        return new Entity(result as ServerContract.Types.entity_info)
+    }
+
+    async getProjection(id: UInt64Type, taskCount?: number): Promise<unknown> {
+        return this.server.readonly('getprojstate', {
+            entity_id: id,
+            task_count: taskCount,
+        })
     }
 
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
-    ): Promise<(Ship | Warehouse | Container)[]> {
+        kind?: EntityTypeName
+    ): Promise<Entity[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         const entities = result as ServerContract.Types.entity_info[]
-        return entities.map((entity) => this.wrapEntity(entity))
+        return entities.map((e) => new Entity(e))
+    }
+
+    async getAllEntities(kind?: EntityTypeName): Promise<ServerContract.Types.entity_row[]> {
+        const rows = await this.server.table('entity').all()
+        if (!kind) {
+            return rows
+        }
+        const wanted = Name.from(kind)
+        return rows.filter((row) => wanted.equals(row.kind))
     }
 
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
+        kind?: EntityTypeName
     ): Promise<ServerContract.Types.entity_summary[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getsummaries', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
-    async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity('ship', id)) as Ship
-    }
-
-    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity('warehouse', id)) as Warehouse
-    }
-
-    async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity('container', id)) as Container
-    }
-
-    async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
-        return (await this.getEntities(owner, 'ship')) as Ship[]
-    }
-
-    async getWarehouses(owner: NameType | ServerContract.Types.player_row): Promise<Warehouse[]> {
-        return (await this.getEntities(owner, 'warehouse')) as Warehouse[]
-    }
-
-    async getContainers(owner: NameType | ServerContract.Types.player_row): Promise<Container[]> {
-        return (await this.getEntities(owner, 'container')) as Container[]
-    }
-
-    async getShipSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'ship')
-    }
-
-    async getWarehouseSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'warehouse')
-    }
-
-    async getContainerSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        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)
-        }
-    }
-
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner

package/src/managers/epochs.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import type {ServerContract} from '../contracts'
 
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
@@ -8,6 +9,11 @@ export class EpochsManager extends BaseManager {
         return getCurrentEpoch(game)
     }
 
+    async getFinalizedEpoch(reload = false): Promise<UInt64> {
+        const state = await this.getState(reload)
+        return state.currentEpoch
+    }
+
     async getCurrent(): Promise<EpochInfo> {
         const game = await this.getGame()
         const epoch = await this.getCurrentHeight()
@@ -44,4 +50,38 @@ export class EpochsManager extends BaseManager {
         const remaining = await this.getTimeRemaining()
         return durationMs <= remaining
     }
+
+    async getEpochRow(epoch: UInt64Type): Promise<ServerContract.Types.epoch_row | undefined> {
+        const target = UInt64.from(epoch)
+        return this.server.table('epoch').get(target)
+    }
+
+    async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
+        const rows = await this.server.table('epoch').all()
+        if (rows.length === 0) {
+            return undefined
+        }
+        return rows[rows.length - 1]
+    }
+
+    async getOracles(): Promise<ServerContract.Types.oracle_row[]> {
+        return this.server.table('oracles').all()
+    }
+
+    async getThreshold(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.threshold) : 0
+    }
+
+    async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('commit').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
+
+    async getRevealsFor(epoch: UInt64Type): Promise<ServerContract.Types.reveal_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('reveal').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
 }

package/src/managers/flatten-gather-plan.test.ts

@@ -0,0 +1,80 @@
+import {expect, test, describe} from 'bun:test'
+import {makeClient} from '@wharfkit/mock-data'
+import {Serializer} from '@wharfkit/antelope'
+import type {GatherPlan} from '../planner'
+import {ActionsManager} from './actions'
+import {ServerContract} from '../contracts'
+
+const client = makeClient('https://jungle4.greymass.com')
+
+function makeActions() {
+    const realServer = new ServerContract.Contract({client})
+    const stubServer = {
+        account: realServer.account,
+        action: realServer.action.bind(realServer),
+    }
+    const context = {server: stubServer} as any
+    return new ActionsManager(context)
+}
+
+function fakePlan(): GatherPlan {
+    return {
+        cycles: [
+            {
+                rechargeBefore: false,
+                rechargeSeconds: 0,
+                gatherSeconds: 10,
+                batchOre: 30,
+                limpets: [
+                    {slot: 0, quantity: 20, durationSeconds: 10},
+                    {slot: 1, quantity: 10, durationSeconds: 8},
+                ],
+            },
+            {
+                rechargeBefore: true,
+                rechargeSeconds: 5,
+                gatherSeconds: 10,
+                batchOre: 30,
+                limpets: [{slot: 0, quantity: 30, durationSeconds: 10}],
+            },
+        ],
+        cycleCount: 2,
+        totalOre: 60,
+        totalSeconds: 25,
+        cap: 'requested',
+        reachingCount: 2,
+        totalLimpets: 2,
+        warnings: [],
+    }
+}
+
+describe('flattenGatherPlan', () => {
+    test('flattens cycles to [recharge?, gather x limpets] in order with slots', () => {
+        const actions = makeActions().flattenGatherPlan(fakePlan(), {
+            sourceId: 1,
+            destinationId: 1,
+            stratum: 100,
+        })
+        expect(actions.map((a) => a.name.toString())).toEqual([
+            'gather',
+            'gather',
+            'recharge',
+            'gather',
+        ])
+        expect(actions.filter((a) => a.name.toString() === 'recharge').length).toBe(1)
+        const gatherSlots = actions
+            .filter((a) => a.name.toString() === 'gather')
+            .map((a) => {
+                const decoded = Serializer.decode({data: a.data, type: ServerContract.Types.gather})
+                return Number(decoded.slot)
+            })
+        expect(gatherSlots).toEqual([0, 1, 0])
+    })
+
+    test('empty plan produces no actions', () => {
+        const empty = {...fakePlan(), cycles: [], cycleCount: 0, totalOre: 0}
+        expect(
+            makeActions().flattenGatherPlan(empty, {sourceId: 1, destinationId: 1, stratum: 100})
+        ).toHaveLength(0)
+    })
+})

package/src/managers/index.ts

@@ -1,9 +1,28 @@
 export {GameContext} from './context'
 export {BaseManager} from './base'
 export {EntitiesManager} from './entities'
-export type {EntityType} from './entities'
+export type {EntityTypeName} from './entities'
 export {PlayersManager} from './players'
+export type {PlayerRosterEntry} from './players'
 export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
+export {ClusterManager, computeFreeCells} from './cluster'
+export type {GridCell, ClusterCell, Cluster} from './cluster'
+export {NftManager} from './nft'
+export type {NftConfigForItem} from './nft'
+export {PlotManager} from './plot'
+export type {PlotProgress, PlotProgressInputRow} from './plot'
+export {ConstructionManager} from './construction'
+export type {
+    BuildableTarget,
+    BuildState,
+    SourceEntityRef,
+    SourceCargoStack,
+    FinalizerEntityRef,
+    FinalizerCapability,
+    InboundTransfer,
+    ScheduledBuild,
+    Reservation,
+} from './construction-types'

package/src/managers/locations.ts

@@ -1,10 +1,10 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BlockTimestamp, 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'
-import {type DerivedStratum, deriveStrata} from '../derivation'
+import {type DerivedStratum, deriveStrata, getEffectiveReserve} from '../derivation'
 
 export interface LocationStratum extends DerivedStratum {
     reserveMax: number
@@ -24,7 +24,10 @@ export class LocationsManager extends BaseManager {
         return findNearbyPlanets(game.config.seed, origin, maxDistance)
     }
 
-    async getStrata(coords: CoordinatesType): Promise<LocationStratum[]> {
+    async getStrata(
+        coords: CoordinatesType,
+        now: BlockTimestamp = BlockTimestamp.fromMilliseconds(Date.now())
+    ): Promise<LocationStratum[]> {
         const game = await this.getGame()
         const state = await this.getState()
 
@@ -36,33 +39,26 @@ export class LocationsManager extends BaseManager {
             y: coords.y,
         })) as ServerContract.Types.stratum_remaining[]
 
-        const overrideMap = new Map<number, number>()
+        const epochSeconds = Number(game.config.epochtime)
+        const overrideMap = new Map<number, ServerContract.Types.stratum_remaining>()
         for (const o of overrides) {
-            overrideMap.set(Number(o.stratum), Number(o.remaining))
+            overrideMap.set(Number(o.stratum), o)
         }
 
-        return derived.map((s) => ({
-            ...s,
-            reserveMax: s.reserve,
-            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()
+        return derived.map((s) => {
+            const override = overrideMap.get(s.index)
+            const reserve = override
+                ? getEffectiveReserve(
+                      {
+                          remaining: override.remaining,
+                          max_reserve: s.reserve,
+                          last_block: override.last_block,
+                      },
+                      now,
+                      epochSeconds
+                  )
+                : s.reserve
+            return {...s, reserveMax: s.reserve, reserve}
+        })
     }
 }

package/src/managers/nft.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, test} from 'bun:test'
+import {resolveLockedAmount} from './nft'
+
+describe('resolveLockedAmount', () => {
+    test('no fee refunds the full cost', () => {
+        expect(resolveLockedAmount(5_0000n, 0)).toBe(5_0000n)
+    })
+    test('2% fee floors the fee and refunds the remainder', () => {
+        expect(resolveLockedAmount(5_0000n, 200)).toBe(4_9000n)
+    })
+    test('rounding floors the fee (contract uses integer division)', () => {
+        expect(resolveLockedAmount(101n, 250)).toBe(99n) // fee = floor(101*250/10000)=2
+    })
+})

package/src/managers/nft.ts

@@ -0,0 +1,70 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+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>()
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        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/players.ts

@@ -2,6 +2,11 @@ import {Name, type NameType} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Player} from '../entities/player'
 
+export interface PlayerRosterEntry {
+    owner: Name
+    company?: string
+}
+
 export class PlayersManager extends BaseManager {
     async getPlayer(account: NameType): Promise<Player | undefined> {
         const playerRow = await this.server.table('player').get(Name.from(account))
@@ -10,4 +15,24 @@ export class PlayersManager extends BaseManager {
         }
         return new Player(playerRow)
     }
+
+    async getPlayers(): Promise<Player[]> {
+        const rows = await this.server.table('player').all()
+        return rows.map((row) => new Player(row))
+    }
+
+    async getRoster(): Promise<PlayerRosterEntry[]> {
+        const [players, companies] = await Promise.all([
+            this.server.table('player').all(),
+            this.platform.table('company').all(),
+        ])
+        const companyNames = new Map<string, string>()
+        for (const company of companies) {
+            companyNames.set(company.account.toString(), company.name)
+        }
+        return players.map((player) => ({
+            owner: player.owner,
+            company: companyNames.get(player.owner.toString()),
+        }))
+    }
 }

package/src/managers/plot.ts

@@ -0,0 +1,122 @@
+import {Name} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {getRecipe} from '../data/recipes-runtime'
+import {computeInputMass} from '../derivation/crafting'
+import {calc_craft_duration} from '../capabilities/crafting'
+import {TaskType} from '../types'
+import {BaseManager} from './base'
+import type {CrafterStats} from '../types/capabilities'
+import type {ServerContract} from '../contracts'
+import type {BuildableTarget, ScheduledBuild} from './construction-types'
+
+export interface PlotProgressInputRow {
+    itemId: number
+    required: number
+    provided: number
+    missing: number
+}
+
+export interface PlotProgress {
+    targetItemId: number
+    rows: PlotProgressInputRow[]
+    massProvided: number
+    massRequired: number
+    isComplete: boolean
+}
+
+export class PlotManager extends BaseManager {
+    progress(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): PlotProgress {
+        const targetItemId = Number(plot.item_id.toString())
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`No recipe found for item ${targetItemId}`)
+        }
+
+        const plotId = plot.id.toString()
+        const plotCargo = cargo.filter((c) => c.entity_id.toString() === plotId)
+
+        const quantityByItemId = new Map<number, number>()
+        for (const c of plotCargo) {
+            const id = c.item_id.toNumber()
+            quantityByItemId.set(
+                id,
+                (quantityByItemId.get(id) ?? 0) + Number(c.quantity.toString())
+            )
+        }
+
+        const rows: PlotProgressInputRow[] = recipe.inputs.map((input) => {
+            const itemId = input.itemId
+            const required = input.quantity
+            const provided = quantityByItemId.get(itemId) ?? 0
+            const missing = Math.max(0, required - provided)
+            return {itemId, required, provided, missing}
+        })
+
+        const massRequired = computeInputMass(targetItemId)
+        const massProvided = rows.reduce((sum, r) => {
+            const item = getItem(r.itemId)
+            return sum + item.mass * r.provided
+        }, 0)
+        const isComplete = rows.every((r) => r.missing === 0)
+
+        return {targetItemId, rows, massProvided, massRequired, isComplete}
+    }
+
+    buildableTarget(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[],
+        activeTask?: ServerContract.Types.task,
+        scheduledBuild?: ScheduledBuild
+    ): BuildableTarget {
+        const progress = this.progress(plot, cargo)
+        const targetItemId = Number(plot.item_id.toString())
+        const targetItem = getItem(targetItemId)
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`Plot target item ${targetItemId} has no recipe`)
+        }
+
+        let state: BuildableTarget['state']
+        if (scheduledBuild?.hasStarted) {
+            state = 'finalizing'
+        } else if (scheduledBuild) {
+            state = 'scheduled'
+        } else if (progress.isComplete) {
+            state = 'ready'
+        } else {
+            state = 'accepting'
+        }
+
+        return {
+            entityId: plot.id,
+            ownerName: plot.owner,
+            coordinates: plot.coordinates,
+            targetItemId,
+            targetItem,
+            state,
+            recipe,
+            progress,
+            finalizeAction: Name.from('buildplot'),
+            finalizerCapability: 'crafter',
+            activeTask,
+            scheduledBuild,
+        }
+    }
+
+    canBuild(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        return this.progress(plot, cargo).isComplete
+    }
+
+    timeToComplete(plot: ServerContract.Types.entity_info, crafter: CrafterStats): number {
+        const capacity = Number(plot.capacity?.toString() ?? '0')
+        const speed = Number(crafter.speed.toString())
+        if (speed === 0) return 0
+        return calc_craft_duration(speed, capacity).toNumber()
+    }
+}