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

package/src/managers/entities.ts

@@ -1,97 +1,69 @@
 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(
+    async getDepot(
+        depotId: UInt64Type,
         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)
-        }
+    ): Promise<ServerContract.Types.depot_view> {
+        const result = await this.server.readonly('getdepot', {
+            depot_id: depotId,
+            owner: this.resolveOwner(owner),
+        })
+        return result as ServerContract.Types.depot_view
     }
 
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {

package/src/managers/epochs.ts

@@ -1,6 +1,16 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {Checksum256, UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import type {ServerContract} from '../contracts'
+
+export const DEFAULT_EPOCH_DEADLINE = 10800
+
+const EMPTY_SEED = Checksum256.from('0'.repeat(64))
+
+export interface EpochQuorumState {
+    threshold: number
+    finalized: boolean
+}
 
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
@@ -8,6 +18,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 +59,60 @@ 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 getEpochState(epoch: UInt64Type): Promise<EpochQuorumState> {
+        const row = await this.getEpochRow(epoch)
+        if (!row) return {threshold: 0, finalized: false}
+        return {threshold: Number(row.threshold), finalized: !row.seed.equals(EMPTY_SEED)}
+    }
+
+    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 getDeadline(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.deadline) : DEFAULT_EPOCH_DEADLINE
+    }
+
+    async getCloseDueAt(epoch: UInt64Type): Promise<Date> {
+        const info = await this.getByHeight(epoch)
+        const deadline = await this.getDeadline()
+        return new Date(info.start.getTime() + deadline * 1000)
+    }
+
+    async getSecondsUntilClose(epoch: UInt64Type): Promise<number> {
+        const dueAt = await this.getCloseDueAt(epoch)
+        return Math.ceil((dueAt.getTime() - Date.now()) / 1000)
+    }
+
+    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/index.ts

@@ -1,9 +1,46 @@
 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, WrapConfig, WrapGate} from './nft'
+export {BalancesManager} from './balances'
+export type {DepositConfig, PlatformBalance, TokenBalance} from './balances'
+export {JobsManager} from './jobs'
+export {InfluenceManager} from './influence'
+export type {
+    CharterProgress,
+    ContributePreview,
+    ContributePreviewRow,
+    FoundedWorld,
+    FoundedWorldRef,
+    InfluenceStanding,
+    Ballot,
+    BallotVote,
+    NodeProgress,
+    QueuedSeat,
+    VoteOption,
+    VoteStandings,
+} from './influence'
+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/influence.test.ts

@@ -0,0 +1,56 @@
+import {describe, expect, it} from 'bun:test'
+import {Name, UInt64} from '@wharfkit/antelope'
+import {InfluenceManager} from './influence'
+import {coordsToLocationId} from '../types'
+
+const LOCATION = {x: 12, y: 34}
+
+function managerWith(rowsByTable: Record<string, unknown[]>) {
+    const calls: {table: string; scope: unknown}[] = []
+    const table = (name: string, scope: unknown) => {
+        calls.push({table: name, scope})
+        return {all: async () => rowsByTable[name] ?? []}
+    }
+    const ctx = {server: {table}} as never
+    return {manager: new InfluenceManager(ctx), calls}
+}
+
+describe('InfluenceManager scoped table reads', () => {
+    it('getBallotVotes scopes ballotpicks by ballot id and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            ballotpicks: [{account: Name.from('eggmaple.gm'), picks: [2, 1]}],
+        })
+        const rows = await manager.getBallotVotes(7n)
+        expect(calls).toHaveLength(1)
+        expect(calls[0].table).toBe('ballotpicks')
+        expect(UInt64.from(calls[0].scope as never).equals(UInt64.from(7))).toBe(true)
+        expect(rows).toEqual([{account: Name.from('eggmaple.gm'), picks: [2, 1]}])
+    })
+
+    it('getBuiltCharters scopes mandates by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            mandates: [{node_id: 1, repeats: 2}],
+        })
+        const rows = await manager.getBuiltCharters(LOCATION)
+        expect(calls[0].table).toBe('mandates')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{nodeId: 1, repeats: 2}])
+    })
+
+    it('getBuildings scopes buildings by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            buildings: [{entity_id: '9001', building: 3}],
+        })
+        const rows = await manager.getBuildings(LOCATION)
+        expect(calls[0].table).toBe('buildings')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{entityId: 9001n, building: 3}])
+    })
+
+    it('returns an empty array when the scope has no rows', async () => {
+        const {manager} = managerWith({})
+        expect(await manager.getBallotVotes(7n)).toEqual([])
+        expect(await manager.getBuiltCharters(LOCATION)).toEqual([])
+        expect(await manager.getBuildings(LOCATION)).toEqual([])
+    })
+})