@shipload/sdk 0.7.1 → 1.0.0-next.0

package/src/shipload.ts

@@ -1,30 +1,22 @@
-import {
-    APIClient,
-    Bytes,
-    Checksum256,
-    Name,
-    NameType,
-    Serializer,
-    UInt16Type,
-    UInt64,
-    UInt64Type,
-} from '@wharfkit/antelope'
-import {Coordinates, Distance, GoodPrice} from './types'
-import {marketprice, marketprices} from './market'
+import {APIClient} from '@wharfkit/antelope'
 import {PlatformContract, ServerContract} from './contracts'
-import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
-import {ChainDefinition} from '@wharfkit/session'
-import ContractKit, {Contract} from '@wharfkit/contract'
-import {findNearbyPlanets, travelplan} from './travel'
-
-import {Ship} from './ship'
-import {EpochInfo, getCurrentEpoch, getEpochInfo} from './epoch'
-import {hasSystem} from './system'
+import type {ChainDefinition} from '@wharfkit/common'
+import ContractKit, {type Contract} from '@wharfkit/contract'
+
+import {GameContext} from './managers/context'
+import type {EntitiesManager} from './managers/entities'
+import type {PlayersManager} from './managers/players'
+import type {LocationsManager} from './managers/locations'
+import type {EpochsManager} from './managers/epochs'
+import type {ActionsManager} from './managers/actions'
+import type {SubscriptionsManager} from './subscriptions/manager'
+import type {GameState} from './entities/gamestate'
 
 interface ShiploadOptions {
     platformContractName?: string
     serverContractName?: string
     client?: APIClient
+    subscriptionsUrl?: string
 }
 
 interface ShiploadConstructorOptions extends ShiploadOptions {
@@ -33,22 +25,25 @@ interface ShiploadConstructorOptions extends ShiploadOptions {
 }
 
 export class Shipload {
-    public client: APIClient
-    public server: Contract
-    public platform: Contract
-    public game: PlatformContract.Types.game_row | undefined
+    private readonly _context: GameContext
 
     constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions) {
         const {client, platformContract, serverContract} = constructorOptions || {}
-        this.client = client || new APIClient({url: chain.url})
+        const apiClient = client || new APIClient({url: chain.url})
 
-        this.platform = platformContract
+        const platform = platformContract
             ? platformContract
-            : new PlatformContract.Contract({client: this.client})
+            : new PlatformContract.Contract({client: apiClient})
 
-        this.server = serverContract
+        const server = serverContract
             ? serverContract
-            : new ServerContract.Contract({client: this.client})
+            : new ServerContract.Contract({client: apiClient})
+
+        this._context = new GameContext(apiClient, server, platform)
+
+        if (constructorOptions?.subscriptionsUrl) {
+            this._context.setSubscriptionsUrl(constructorOptions.subscriptionsUrl)
+        }
     }
 
     static async load(
@@ -80,155 +75,47 @@ export class Shipload {
         })
     }
 
-    async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
-        if (!reload && this.game) {
-            return this.game
-        }
-        const game = await this.platform.table('games').get()
-        if (!game) {
-            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
-        }
-        this.game = game
-        return game
+    get client(): APIClient {
+        return this._context.client
     }
 
-    async getState(): Promise<ServerContract.Types.state_row> {
-        const state = await this.server.table('state').get()
-        if (!state) {
-            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
-        }
-        return state
+    get server(): Contract {
+        return this._context.server
     }
 
-    async getShip(ship_id: UInt64Type): Promise<Ship> {
-        const ship = await this.server.table('ship').get(UInt64.from(ship_id))
-        if (!ship) {
-            throw new Error('No ship found')
-        }
-        return new Ship(ship)
+    get platform(): Contract {
+        return this._context.platform
     }
 
-    async getShips(player: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
-        let account: Name
-        if (player instanceof ServerContract.Types.player_row) {
-            account = player.owner
-        } else {
-            account = Name.from(player)
-        }
-        const from = Serializer.decode({
-            data:
-                Serializer.encode({object: UInt64.from(UInt64.min)}).hexString +
-                Serializer.encode({object: Name.from(account)}).hexString,
-            type: 'uint128',
-        })
-        const to = Serializer.decode({
-            data:
-                Serializer.encode({object: UInt64.from(UInt64.max)}).hexString +
-                Serializer.encode({object: Name.from(account)}).hexString,
-            type: 'uint128',
-        })
-        const ships = await this.server
-            .table('ship')
-            .query({
-                key_type: 'i128',
-                index_position: 'secondary',
-                from,
-                to,
-            })
-            .all()
-        return ships.map((ship) => new Ship(ship))
+    get entities(): EntitiesManager {
+        return this._context.entities
     }
 
-    async marketprice(
-        location: ServerContract.ActionParams.Type.coordinates,
-        good_id: number
-    ): Promise<GoodPrice> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketprice(location, good_id, game.config.seed, state)
+    get players(): PlayersManager {
+        return this._context.players
     }
 
-    async marketprices(
-        location: ServerContract.ActionParams.Type.coordinates
-    ): Promise<GoodPrice[]> {
-        const game = await this.getGame()
-        const state = await this.getState()
-        return marketprices(location, game.config.seed, state)
+    get locations(): LocationsManager {
+        return this._context.locations
     }
 
-    async hasSystem(location: ServerContract.ActionParams.Type.coordinates): Promise<boolean> {
-        const game = await this.getGame()
-        return hasSystem(game.config.seed, location)
+    get epochs(): EpochsManager {
+        return this._context.epochs
     }
 
-    async findNearbyPlanets(
-        origin: ServerContract.ActionParams.Type.coordinates,
-        maxDistance: UInt16Type = 20
-    ): Promise<Distance[]> {
-        const game = await this.getGame()
-        return findNearbyPlanets(game.config.seed, origin, maxDistance)
+    get actions(): ActionsManager {
+        return this._context.actions
     }
 
-    async travelplan(
-        ship: ServerContract.Types.ship_row,
-        origin: ServerContract.ActionParams.Type.coordinates,
-        destination: ServerContract.ActionParams.Type.coordinates,
-        recharge = false
-    ): Promise<ServerContract.Types.travel_plan> {
-        const game = await this.getGame()
-        const cargos = await this.server.table('cargo').all({
-            from: ship.id,
-            to: ship.id,
-            index_position: 'secondary',
-        })
-        return travelplan(game, ship, cargos, origin, destination, recharge)
-    }
-
-    async getCargo(
-        ship: UInt64Type | ServerContract.Types.ship_row
-    ): Promise<ServerContract.Types.cargo_row[]> {
-        let shipId: UInt64
-        if (ship instanceof ServerContract.Types.ship_row) {
-            shipId = UInt64.from(ship.id)
-        } else {
-            shipId = UInt64.from(ship)
-        }
-
-        const cargoItems = await this.server
-            .table('cargo')
-            .query({
-                key_type: 'i64',
-                index_position: 'secondary',
-                from: shipId,
-                to: shipId,
-            })
-            .all()
-
-        return cargoItems
+    get subscriptions(): SubscriptionsManager {
+        return this._context.subscriptions
     }
 
-    async getCurrentEpochHeight(): Promise<UInt64> {
-        const game = await this.getGame()
-        return getCurrentEpoch(game)
-    }
-
-    async getCurrentEpoch(): Promise<EpochInfo> {
-        const game = await this.getGame()
-        const epoch = await this.getCurrentEpochHeight()
-        return getEpochInfo(game, epoch)
-    }
-
-    async getEpoch(height: UInt64Type): Promise<EpochInfo> {
-        const game = await this.getGame()
-        return getEpochInfo(game, UInt64.from(height))
+    async getGame(reload = false): Promise<PlatformContract.Types.game_row> {
+        return this._context.getGame(reload)
     }
 
-    async getLocation(location: Coordinates) {
-        const hash = Checksum256.hash(Bytes.from(`${location.x}-${location.y}`, 'utf8'))
-        return this.server.table('location').all({
-            index_position: 'secondary',
-            from: hash,
-            to: hash,
-        })
+    async getState(reload = false): Promise<GameState> {
+        return this._context.getState(reload)
     }
 }

package/src/subscriptions/connection.ts

@@ -0,0 +1,154 @@
+import type {ClientMessage, ServerMessage} from './types'
+import {debug} from './debug'
+
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting'
+
+export interface WebSocketConnectionOptions {
+    url: string
+    onMessage: (message: ServerMessage) => void
+    onStateChange?: (state: ConnectionState) => void
+}
+
+export class WebSocketConnection {
+    private ws: WebSocket | null = null
+    private url: string
+    private onMessage: (message: ServerMessage) => void
+    private onStateChange?: (state: ConnectionState) => void
+    private reconnectAttempts = 0
+    private reconnectTimeout: ReturnType<typeof setTimeout> | null = null
+    private _state: ConnectionState = 'disconnected'
+    private shouldReconnect = true
+    private sendQueue: string[] = []
+
+    private static readonly MIN_RECONNECT_DELAY = 1000
+    private static readonly MAX_RECONNECT_DELAY = 30000
+    private static readonly RECONNECT_MULTIPLIER = 2
+
+    constructor(options: WebSocketConnectionOptions) {
+        this.url = options.url
+        this.onMessage = options.onMessage
+        this.onStateChange = options.onStateChange
+    }
+
+    get state(): ConnectionState {
+        return this._state
+    }
+
+    private setState(state: ConnectionState) {
+        if (this._state !== state) {
+            this._state = state
+            this.onStateChange?.(state)
+        }
+    }
+
+    connect() {
+        if (this.ws) {
+            return
+        }
+
+        this.shouldReconnect = true
+        this.setState('connecting')
+        debug('Connecting to', this.url)
+
+        try {
+            this.ws = new WebSocket(this.url)
+
+            this.ws.onopen = () => {
+                debug('Connected')
+                this.reconnectAttempts = 0
+                this.setState('connected')
+                while (
+                    this.sendQueue.length > 0 &&
+                    this.ws &&
+                    this.ws.readyState === WebSocket.OPEN
+                ) {
+                    this.ws.send(this.sendQueue.shift()!)
+                }
+            }
+
+            this.ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data) as ServerMessage
+                    this.onMessage(message)
+                } catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('[WS] Failed to parse message:', e)
+                }
+            }
+
+            this.ws.onclose = () => {
+                this.ws = null
+                this.sendQueue.length = 0
+
+                if (this.shouldReconnect) {
+                    this.setState('reconnecting')
+                    this.scheduleReconnect()
+                } else {
+                    this.setState('disconnected')
+                }
+            }
+        } catch (e) {
+            // eslint-disable-next-line no-console
+            console.error('[WS] Failed to create connection:', e)
+            this.ws = null
+            if (this.shouldReconnect) {
+                this.setState('reconnecting')
+                this.scheduleReconnect()
+            }
+        }
+    }
+
+    private scheduleReconnect() {
+        if (this.reconnectTimeout) {
+            return
+        }
+
+        const delay = Math.min(
+            WebSocketConnection.MIN_RECONNECT_DELAY *
+                WebSocketConnection.RECONNECT_MULTIPLIER ** this.reconnectAttempts,
+            WebSocketConnection.MAX_RECONNECT_DELAY
+        )
+
+        debug(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1})`)
+
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null
+            this.reconnectAttempts++
+            this.connect()
+        }, delay)
+    }
+
+    disconnect() {
+        this.shouldReconnect = false
+
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout)
+            this.reconnectTimeout = null
+        }
+
+        if (this.ws) {
+            this.ws.close()
+            this.ws = null
+        }
+
+        this.sendQueue.length = 0
+        this.setState('disconnected')
+    }
+
+    close() {
+        this.disconnect()
+    }
+
+    send(message: ClientMessage) {
+        const data = JSON.stringify(message)
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(data)
+            return
+        }
+        this.sendQueue.push(data)
+    }
+
+    get isConnected(): boolean {
+        return this._state === 'connected'
+    }
+}

package/src/subscriptions/debug.ts

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+
+let enabled = false
+
+export function setSubscriptionsDebug(on: boolean): void {
+    enabled = on
+}
+
+export function isSubscriptionsDebugEnabled(): boolean {
+    return enabled
+}
+
+export function debug(...args: unknown[]): void {
+    if (enabled) {
+        console.log('[WS]', ...args)
+    }
+}

package/src/subscriptions/index.ts

@@ -0,0 +1,5 @@
+export * from './connection'
+export * from './types'
+export * from './manager'
+export * from './mappers'
+export {setSubscriptionsDebug, isSubscriptionsDebugEnabled} from './debug'

package/src/subscriptions/manager.ts

@@ -0,0 +1,240 @@
+import {WebSocketConnection} from './connection'
+import type {
+    BoundingBox,
+    BoundsDeltaMessage,
+    ClientMessage,
+    ServerMessage,
+    SnapshotMessage,
+    SubscribeEntityMessage,
+    SubscribeMessage,
+    UnsubscribeEntityMessage,
+    UpdateBoundsMessage,
+    UpdateMessage,
+    WireEntity,
+} from './types'
+import {mapEntity, parseWireEntity} from './mappers'
+import type {Ship} from '../entities/ship'
+import type {Warehouse} from '../entities/warehouse'
+import type {Container} from '../entities/container'
+
+export type SubscriptionEntityType = 'ship' | 'warehouse' | 'container'
+export type EntityInstance = Ship | Warehouse | Container
+
+export interface SubscriptionsOptions {
+    url: string
+}
+
+export interface BoundsSubscriptionHandle {
+    readonly subId: string
+    unsubscribe(): void
+    updateBounds(bounds: BoundingBox): void
+    current: Map<number, EntityInstance>
+}
+
+export interface EntitySubscriptionHandle {
+    readonly subId: string
+    readonly entityType: SubscriptionEntityType
+    readonly entityId: string
+    unsubscribe(): void
+    current: EntityInstance | null
+}
+
+export class SubscriptionsManager {
+    private readonly conn: WebSocketConnection
+    private readonly entitySubs = new Map<
+        string,
+        {
+            type: SubscriptionEntityType
+            id: string
+            onUpdate: (e: EntityInstance) => void
+            handle: EntitySubscriptionHandle
+        }
+    >()
+    private readonly boundsSubs = new Map<
+        string,
+        {
+            onSnapshot?: (entities: EntityInstance[]) => void
+            onUpdate?: (entity: EntityInstance) => void
+            onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
+            handle: BoundsSubscriptionHandle
+        }
+    >()
+    private subCounter = 0
+
+    constructor(opts: SubscriptionsOptions) {
+        this.conn = new WebSocketConnection({
+            url: opts.url,
+            onMessage: (m) => this.onMessage(m),
+        })
+        this.conn.connect()
+    }
+
+    close() {
+        this.conn.close()
+    }
+
+    private generateSubID(prefix: string): string {
+        this.subCounter += 1
+        return `${prefix}-${this.subCounter}-${Math.random().toString(36).slice(2, 8)}`
+    }
+
+    private sendMessage(msg: ClientMessage) {
+        this.conn.send(msg)
+    }
+
+    subscribeEntity(
+        type: SubscriptionEntityType,
+        id: string,
+        onUpdate: (e: EntityInstance) => void
+    ): EntitySubscriptionHandle {
+        const subId = this.generateSubID('ent')
+        const msg: SubscribeEntityMessage = {
+            type: 'subscribe_entity',
+            sub_id: subId,
+            entity_type: type,
+            entity_id: id,
+        }
+        const handle: EntitySubscriptionHandle = {
+            subId,
+            entityType: type,
+            entityId: id,
+            unsubscribe: () => this.unsubscribeEntity(subId),
+            current: null,
+        }
+        this.entitySubs.set(subId, {type, id, onUpdate, handle})
+        this.sendMessage(msg)
+        return handle
+    }
+
+    private unsubscribeEntity(subId: string) {
+        const entry = this.entitySubs.get(subId)
+        if (!entry) return
+        this.entitySubs.delete(subId)
+        const msg: UnsubscribeEntityMessage = {type: 'unsubscribe_entity', sub_id: subId}
+        this.sendMessage(msg)
+    }
+
+    subscribeBounds(
+        bounds: BoundingBox,
+        handlers: {
+            onSnapshot?: (entities: EntityInstance[]) => void
+            onUpdate?: (entity: EntityInstance) => void
+            onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
+            owner?: string
+            prioritizeOwner?: string
+        }
+    ): BoundsSubscriptionHandle {
+        const subId = this.generateSubID('bnd')
+        const msg: SubscribeMessage = {
+            type: 'subscribe',
+            sub_id: subId,
+            bounds,
+            owner: handlers.owner,
+            prioritize_owner: handlers.prioritizeOwner,
+        }
+        const handle: BoundsSubscriptionHandle = {
+            subId,
+            unsubscribe: () => this.unsubscribeBounds(subId),
+            updateBounds: (b) => this.updateBounds(subId, b),
+            current: new Map(),
+        }
+        this.boundsSubs.set(subId, {
+            onSnapshot: handlers.onSnapshot,
+            onUpdate: handlers.onUpdate,
+            onBoundsDelta: handlers.onBoundsDelta,
+            handle,
+        })
+        this.sendMessage(msg)
+        return handle
+    }
+
+    private unsubscribeBounds(subId: string) {
+        this.boundsSubs.delete(subId)
+        this.sendMessage({type: 'unsubscribe', sub_id: subId})
+    }
+
+    private updateBounds(subId: string, bounds: BoundingBox) {
+        const msg: UpdateBoundsMessage = {type: 'update_bounds', sub_id: subId, bounds}
+        this.sendMessage(msg)
+    }
+
+    private onMessage(msg: ServerMessage) {
+        switch (msg.type) {
+            case 'snapshot':
+                this.handleSnapshot(msg)
+                break
+            case 'update':
+                this.handleUpdate(msg)
+                break
+            case 'bounds_delta':
+                this.handleBoundsDelta(msg)
+                break
+            case 'error':
+                this.handleError(msg)
+                break
+        }
+    }
+
+    private parseEntity(raw: WireEntity): EntityInstance {
+        const ei = parseWireEntity(raw)
+        return mapEntity(ei)
+    }
+
+    private handleSnapshot(msg: SnapshotMessage) {
+        const entSub = this.entitySubs.get(msg.sub_id)
+        if (entSub) {
+            if (msg.entities.length > 0) {
+                const ent = this.parseEntity(msg.entities[0])
+                entSub.handle.current = ent
+                entSub.onUpdate(ent)
+            }
+            return
+        }
+        const boundsSub = this.boundsSubs.get(msg.sub_id)
+        if (boundsSub) {
+            const ents = msg.entities.map((e) => this.parseEntity(e))
+            boundsSub.handle.current.clear()
+            for (const e of ents) boundsSub.handle.current.set(Number(e.id), e)
+            boundsSub.onSnapshot?.(ents)
+        }
+    }
+
+    private handleUpdate(msg: UpdateMessage) {
+        const ent = this.parseEntity(msg.entity)
+        for (const subId of msg.sub_ids) {
+            const entSub = this.entitySubs.get(subId)
+            if (entSub) {
+                entSub.handle.current = ent
+                entSub.onUpdate(ent)
+                continue
+            }
+            const boundsSub = this.boundsSubs.get(subId)
+            if (boundsSub) {
+                boundsSub.handle.current.set(msg.entity_id, ent)
+                boundsSub.onUpdate?.(ent)
+            }
+        }
+    }
+
+    private handleBoundsDelta(msg: BoundsDeltaMessage) {
+        const sub = this.boundsSubs.get(msg.sub_id)
+        if (!sub) return
+        const entered = msg.entered.map((e) => this.parseEntity(e))
+        for (const e of entered) sub.handle.current.set(Number(e.id), e)
+        for (const id of msg.exited) sub.handle.current.delete(id)
+        sub.onBoundsDelta?.(entered, msg.exited)
+    }
+
+    private handleError(msg: {sub_id?: string; error: string}) {
+        if (!msg.sub_id) return
+        const entSub = this.entitySubs.get(msg.sub_id)
+        if (entSub) {
+            this.entitySubs.delete(msg.sub_id)
+            return
+        }
+        const boundsSub = this.boundsSubs.get(msg.sub_id)
+        if (boundsSub) {
+            this.boundsSubs.delete(msg.sub_id)
+        }
+    }
+}