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

package/src/scheduling/task-cargo.test.ts

@@ -0,0 +1,110 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType} from '../index-module'
+import {taskCargoChanges, taskCargoChangesChecked} from './task-cargo'
+
+function cargoItem(itemId: number, quantity: number) {
+    return ServerContract.Types.cargo_item.from({item_id: itemId, stats: 0, modules: [], quantity})
+}
+
+function craftTask(couplings: ReturnType<typeof coupling>[]) {
+    return ServerContract.Types.task.from({
+        type: TaskType.CRAFT,
+        duration: 60,
+        cancelable: 0,
+        cargo: [cargoItem(401, 19680), cargoItem(10008, 1968)],
+        couplings,
+    })
+}
+
+function coupling() {
+    return ServerContract.Types.coupling.from({
+        counterpart: {entity_type: 'warehouse', entity_id: 51},
+        hold: 1,
+        kind: 3,
+    })
+}
+
+describe('taskCargoChanges', () => {
+    test('a self-craft consumes inputs and delivers the output to the crafter', () => {
+        const changes = taskCargoChanges(craftTask([]))
+
+        expect(changes).toEqual([
+            {direction: 'out', item_id: 401, stats: 0n, modules: [], quantity: 19680},
+            {direction: 'in', item_id: 10008, stats: 0n, modules: [], quantity: 1968},
+        ])
+    })
+
+    test('a coupled craft consumes inputs but does not deliver the output to the crafter', () => {
+        const changes = taskCargoChanges(craftTask([coupling()]))
+
+        expect(changes).toEqual([
+            {direction: 'out', item_id: 401, stats: 0n, modules: [], quantity: 19680},
+        ])
+    })
+})
+
+describe('TaskType', () => {
+    test('covers the civic transfer task types the contract defines', () => {
+        expect(TaskType.CIVIC_DEPOSIT).toBe(21)
+        expect(TaskType.CIVIC_WITHDRAW).toBe(22)
+    })
+
+    test('keeps the former depot names as aliases of the civic transfer types', () => {
+        expect(TaskType.DEPOT_STORE).toBe(TaskType.CIVIC_DEPOSIT)
+        expect(TaskType.DEPOT_TAKE).toBe(TaskType.CIVIC_WITHDRAW)
+    })
+})
+
+function simpleTask(type: number) {
+    return ServerContract.Types.task.from({
+        type,
+        duration: 60,
+        cancelable: 0,
+        cargo: [cargoItem(401, 100)],
+        couplings: [],
+    })
+}
+
+describe('taskCargoChanges task coverage', () => {
+    test('a depot store moves cargo out of the entity', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.CIVIC_DEPOSIT))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('out')
+    })
+
+    test('a depot take moves cargo into the entity', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.CIVIC_WITHDRAW))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('in')
+    })
+
+    test('an upgrade consumes its cargo', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.UPGRADE))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('out')
+    })
+
+    test('an undeploy returns cargo to the entity', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.UNDEPLOY))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('in')
+    })
+})
+
+describe('taskCargoChangesChecked', () => {
+    test('reports a known task type with its changes', () => {
+        const result = taskCargoChangesChecked(simpleTask(TaskType.CIVIC_WITHDRAW))
+        expect(result.known).toBe(true)
+        if (result.known) expect(result.changes[0].direction).toBe('in')
+    })
+
+    test('distinguishes an unrecognised task type from one that moves nothing', () => {
+        const unknown = taskCargoChangesChecked(simpleTask(99))
+        expect(unknown.known).toBe(false)
+        if (!unknown.known) expect(unknown.taskType).toBe(99)
+
+        const travel = taskCargoChangesChecked(simpleTask(TaskType.TRAVEL))
+        expect(travel.known).toBe(true)
+        if (travel.known) expect(travel.changes).toHaveLength(0)
+    })
+})

package/src/scheduling/task-cargo.ts

@@ -0,0 +1,62 @@
+import type {ServerContract} from '../contracts'
+import {type TaskCargoRule, taskCargoRule} from './task-effects'
+
+export type TaskCargoDirection = 'in' | 'out'
+
+export interface TaskCargoChange {
+    direction: TaskCargoDirection
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+}
+
+export type TaskCargoResult =
+    | {known: true; changes: TaskCargoChange[]}
+    | {known: false; taskType: number}
+
+function toChange(
+    item: ServerContract.Types.cargo_item,
+    direction: TaskCargoDirection
+): TaskCargoChange {
+    return {
+        direction,
+        item_id: Number(item.item_id),
+        stats: BigInt(item.stats.toString()),
+        modules: item.modules ?? [],
+        quantity: Number(item.quantity),
+    }
+}
+
+function changesForRule(rule: TaskCargoRule, task: ServerContract.Types.task): TaskCargoChange[] {
+    const items = task.cargo ?? []
+    if (items.length === 0) return []
+    switch (rule) {
+        case 'all-in':
+        case 'undeploy':
+            return items.map((i) => toChange(i, 'in'))
+        case 'all-out':
+            return items.map((i) => toChange(i, 'out'))
+        case 'gather':
+            return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
+        case 'craft':
+            return [
+                ...items.slice(0, -1).map((i) => toChange(i, 'out')),
+                ...(task.couplings.length > 0 ? [] : [toChange(items[items.length - 1], 'in')]),
+            ]
+        default:
+            return []
+    }
+}
+
+export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+    const rule = taskCargoRule(Number(task.type))
+    return rule ? changesForRule(rule, task) : []
+}
+
+export function taskCargoChangesChecked(task: ServerContract.Types.task): TaskCargoResult {
+    const type = Number(task.type)
+    const rule = taskCargoRule(type)
+    if (!rule) return {known: false, taskType: type}
+    return {known: true, changes: changesForRule(rule, task)}
+}

package/src/scheduling/task-effects.test.ts

@@ -0,0 +1,35 @@
+import {describe, expect, test} from 'bun:test'
+import {TaskType} from '../types'
+import {taskCargoRule} from './task-effects'
+
+describe('taskCargoRule', () => {
+    test('maps the task types that move cargo out of the entity', () => {
+        expect(taskCargoRule(TaskType.UNLOAD)).toBe('all-out')
+        expect(taskCargoRule(TaskType.UPGRADE)).toBe('all-out')
+        expect(taskCargoRule(TaskType.CONTRIBUTE)).toBe('all-out')
+        expect(taskCargoRule(TaskType.CIVIC_DEPOSIT)).toBe('all-out')
+    })
+
+    test('maps the task types that move cargo into the entity', () => {
+        expect(taskCargoRule(TaskType.LOAD)).toBe('all-in')
+        expect(taskCargoRule(TaskType.UNWRAP)).toBe('all-in')
+        expect(taskCargoRule(TaskType.CIVIC_WITHDRAW)).toBe('all-in')
+    })
+
+    test('maps the conditional task types to their own rules', () => {
+        expect(taskCargoRule(TaskType.GATHER)).toBe('gather')
+        expect(taskCargoRule(TaskType.CRAFT)).toBe('craft')
+        expect(taskCargoRule(TaskType.UNDEPLOY)).toBe('undeploy')
+    })
+
+    test('maps the task types that move no cargo', () => {
+        expect(taskCargoRule(TaskType.TRAVEL)).toBe('none')
+        expect(taskCargoRule(TaskType.RECHARGE)).toBe('none')
+        expect(taskCargoRule(TaskType.DEMOLISH)).toBe('none')
+        expect(taskCargoRule(TaskType.BUILDPLOT)).toBe('none')
+    })
+
+    test('returns undefined for a task type the table does not know', () => {
+        expect(taskCargoRule(99)).toBeUndefined()
+    })
+})

package/src/scheduling/task-effects.ts

@@ -0,0 +1,34 @@
+import {TaskType} from '../types'
+
+export type TaskCargoRule = 'none' | 'all-in' | 'all-out' | 'gather' | 'craft' | 'undeploy'
+
+// Transcribed from the switch in contracts/src/server/src/projection.cpp.
+export const TASK_CARGO_EFFECTS: ReadonlyMap<number, TaskCargoRule> = new Map<
+    number,
+    TaskCargoRule
+>([
+    [TaskType.IDLE, 'none'],
+    [TaskType.TRAVEL, 'none'],
+    [TaskType.RECHARGE, 'none'],
+    [TaskType.WARP, 'none'],
+    [TaskType.TRANSIT, 'none'],
+    [TaskType.LAUNCH, 'none'],
+    [TaskType.DEMOLISH, 'none'],
+    [TaskType.BUILDPLOT, 'none'],
+    [TaskType.CHARGE, 'none'],
+    [TaskType.SHUTTLE, 'none'],
+    [TaskType.LOAD, 'all-in'],
+    [TaskType.UNWRAP, 'all-in'],
+    [TaskType.CIVIC_WITHDRAW, 'all-in'],
+    [TaskType.UNLOAD, 'all-out'],
+    [TaskType.UPGRADE, 'all-out'],
+    [TaskType.CONTRIBUTE, 'all-out'],
+    [TaskType.CIVIC_DEPOSIT, 'all-out'],
+    [TaskType.GATHER, 'gather'],
+    [TaskType.CRAFT, 'craft'],
+    [TaskType.UNDEPLOY, 'undeploy'],
+])
+
+export function taskCargoRule(taskType: number): TaskCargoRule | undefined {
+    return TASK_CARGO_EFFECTS.get(taskType)
+}

package/src/scheduling/unwrap.test.ts

@@ -0,0 +1,86 @@
+import {describe, expect, test} from 'bun:test'
+import {
+    derivedLoaders,
+    unwrapTransitDuration,
+    unwrapLoadDuration,
+    estimateUnwrapDuration,
+    incomingHoldMass,
+    projectedPeakCargomass,
+} from './unwrap'
+
+describe('unwrap duration mirror', () => {
+    test('derivedLoaders aggregates lanes like derived_loaders()', () => {
+        expect(derivedLoaders([])).toBeNull()
+        expect(
+            derivedLoaders([
+                {mass: 1000, thrust: 10},
+                {mass: 1400, thrust: 20},
+            ])
+        ).toEqual({mass: 1200, thrust: 30, quantity: 2}) // floor(2400/2)=1200, sum thrust, count
+    })
+
+    test('transit floors distance then flight time', () => {
+        // distance = floor(sqrt(3^2+4^2)*10000)=50000; accel=400/(mass*100)*10000; flight=floor(2*sqrt(d/accel))
+        const mass = 1000
+        const accel = (400 / (mass * 100)) * 10000
+        const expected = Math.floor(2 * Math.sqrt(50000 / accel))
+        expect(unwrapTransitDuration(mass, {x: 0, y: 0}, {x: 3, y: 4})).toBe(expected)
+    })
+
+    test('load uses altitude z, adds loader mass, divides by quantity', () => {
+        const loaders = {mass: 1200, thrust: 30, quantity: 2}
+        const itemMass = 800
+        const accel = (30 / ((itemMass + 1200) * 100)) * 10000
+        const flight = Math.floor(2 * Math.sqrt(3000 / accel))
+        expect(unwrapLoadDuration(loaders, itemMass, 3000)).toBe(Math.floor(flight / 2))
+    })
+
+    test('zero item mass and no loaders are safe', () => {
+        expect(unwrapTransitDuration(0, {x: 0, y: 0}, {x: 9, y: 9})).toBe(0)
+        expect(unwrapLoadDuration(null, 500, 3000)).toBe(0)
+    })
+
+    test('load altitude is floored so ground-level (z=0) destinations are not instant', () => {
+        const loaders = {mass: 500, thrust: 200, quantity: 1}
+        const atZero = unwrapLoadDuration(loaders, 1000, 0)
+        const at800 = unwrapLoadDuration(loaders, 1000, 800)
+        expect(atZero).toBeGreaterThan(0)
+        expect(atZero).toBe(at800)
+    })
+
+    test('estimateUnwrapDuration uses worst-loader baseline when dest has no loaders', () => {
+        // IRON (101); same coords so transit is 0 and the estimate is baseline load alone
+        const item = {itemId: 101, quantity: 10, modules: [], originX: 0, originY: 0}
+        const bareDest = {loader_lanes: [], coordinates: {x: 0, y: 0, z: 800}}
+
+        const bare = estimateUnwrapDuration(bareDest, item)
+        expect(bare).toBeGreaterThan(0)
+
+        const loadedDest = {
+            loader_lanes: [{mass: 500, thrust: 200}],
+            coordinates: {x: 0, y: 0, z: 800},
+        }
+        const loaded = estimateUnwrapDuration(loadedDest, item)
+        expect(loaded).toBeLessThanOrEqual(bare)
+
+        expect(unwrapLoadDuration(null, 500, 3000)).toBe(0)
+    })
+})
+
+test('incomingHoldMass sums incoming-kind hold mass', () => {
+    expect(incomingHoldMass([])).toBe(0)
+    // PUSH(2) + FLIGHT(5) count; BUILD(4) does not
+    expect(
+        incomingHoldMass([
+            {kind: 2, incoming_mass: 100},
+            {kind: 4, incoming_mass: 999},
+            {kind: 5, incoming_mass: 50},
+        ])
+    ).toBe(150)
+})
+
+test('projectedPeakCargomass tracks the running peak from cargomass', () => {
+    const entity = {cargomass: 1000, lanes: [], cargo: [], schedule: undefined} as never
+    // No pending tasks: peak = base + candidate add.
+    expect(projectedPeakCargomass(entity, new Date(0), 500)).toBe(1500)
+})

package/src/scheduling/unwrap.ts

@@ -0,0 +1,190 @@
+import type {UInt16Type, UInt32Type} from '@wharfkit/antelope'
+import {calcCargoItemMass} from '../capabilities/storage'
+import type {ServerContract} from '../contracts'
+import {MASS_STAT_SCALE, PRECISION} from '../types'
+import * as sched from './schedule'
+import {taskCargoEffect} from './availability'
+import {candidateLaneCompletesAt} from './lanes'
+
+const NFT_TRANSIT_THRUST = 400
+const BASELINE_LOADER: DerivedLoaders = {mass: 20, thrust: 1, quantity: 1}
+// ground-level entities (warehouses, z=0) still incur a base orbital climb of load effort
+const MIN_LOAD_Z = 800
+
+export interface DerivedLoaders {
+    mass: number
+    thrust: number
+    quantity: number
+}
+
+export function derivedLoaders(
+    lanes: {mass: UInt32Type | number; thrust: UInt16Type | number}[] | undefined
+): DerivedLoaders | null {
+    if (!lanes || lanes.length === 0) return null
+    let totalMass = 0
+    let totalThrust = 0
+    for (const l of lanes) {
+        totalMass += Number(l.mass)
+        totalThrust += Number(l.thrust)
+    }
+    const count = lanes.length
+    return {
+        mass: Math.floor(totalMass / count),
+        thrust: Math.min(totalThrust, 65_535),
+        quantity: count,
+    }
+}
+
+function acceleration(thrust: number, mass: number): number {
+    if (mass <= 0) return 0
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
+}
+
+function flightTime(distance: number, accel: number): number {
+    if (accel <= 0 || distance <= 0) return 0
+    return Math.floor(2 * Math.sqrt(distance / accel))
+}
+
+function distance2d(ax: number, ay: number, bx: number, by: number): number {
+    const dx = ax - bx
+    const dy = ay - by
+    return Math.floor(Math.sqrt(dx * dx + dy * dy) * PRECISION)
+}
+
+export function unwrapTransitDuration(
+    itemMass: number,
+    origin: {x: number; y: number},
+    dest: {x: number; y: number}
+): number {
+    if (itemMass <= 0) return 0
+    return flightTime(
+        distance2d(origin.x, origin.y, dest.x, dest.y),
+        acceleration(NFT_TRANSIT_THRUST, itemMass)
+    )
+}
+
+export function unwrapLoadDuration(
+    loaders: DerivedLoaders | null,
+    itemMass: number,
+    destZ: number
+): number {
+    if (!loaders || itemMass <= 0) return 0
+    const total = itemMass + loaders.mass
+    const flight = flightTime(Math.max(destZ, MIN_LOAD_Z), acceleration(loaders.thrust, total))
+    return Math.floor(flight / loaders.quantity)
+}
+
+export interface UnwrapItem {
+    itemId: number
+    quantity: number
+    modules: ServerContract.Types.module_entry[]
+    originX: number
+    originY: number
+}
+
+export interface UnwrapDestination {
+    loader_lanes?: {mass: UInt32Type | number; thrust: UInt16Type | number}[]
+    coordinates: {x: UInt32Type | number; y: UInt32Type | number; z?: UInt32Type | number}
+}
+
+export function estimateUnwrapDuration(dest: UnwrapDestination, item: UnwrapItem): number {
+    const itemMass = Number(
+        calcCargoItemMass({
+            item_id: item.itemId as never,
+            quantity: item.quantity as never,
+            modules: item.modules,
+        })
+    )
+    const loaders = derivedLoaders(dest.loader_lanes) ?? BASELINE_LOADER
+    const dz = Number(dest.coordinates.z ?? 0)
+    const load = unwrapLoadDuration(loaders, itemMass, dz)
+    const transit = unwrapTransitDuration(
+        itemMass,
+        {x: item.originX, y: item.originY},
+        {
+            x: Number(dest.coordinates.x),
+            y: Number(dest.coordinates.y),
+        }
+    )
+    return load + transit
+}
+
+// Hold kinds that count as incoming (mirror is_incoming_hold_kind in holds.hpp).
+const INCOMING_HOLD_KINDS = new Set<number>([2, 3, 5])
+
+export function incomingHoldMass(
+    holds:
+        | {kind: number | {toNumber(): number}; incoming_mass: number | {toNumber(): number}}[]
+        | undefined
+): number {
+    if (!holds) return 0
+    let total = 0
+    for (const h of holds) {
+        if (INCOMING_HOLD_KINDS.has(Number(h.kind))) total += Number(h.incoming_mass)
+    }
+    return total
+}
+
+type CargoItem = ServerContract.Types.cargo_item
+
+function cargoListMass(items: CargoItem[]): number {
+    let m = 0
+    for (const it of items) m += Number(calcCargoItemMass(it))
+    return m
+}
+
+export function projectedPeakCargomass(
+    entity: sched.ScheduleData & {cargomass: number | {toNumber(): number}},
+    at: Date,
+    addMass: number,
+    removeMass = 0
+): number {
+    const events: {t: number; delta: number}[] = []
+    for (const ordered of sched.orderedTasks(entity)) {
+        const eff = taskCargoEffect(ordered.task)
+        const delta = cargoListMass(eff.added) - cargoListMass(eff.removed)
+        events.push({t: ordered.completesAt.getTime(), delta})
+    }
+    events.push({t: at.getTime(), delta: addMass - removeMass})
+    events.sort((a, b) => (a.t !== b.t ? a.t - b.t : b.delta - a.delta))
+    let running = Number(entity.cargomass)
+    let peak = running
+    for (const e of events) {
+        running += e.delta
+        if (running < 0) running = 0
+        if (running > peak) peak = running
+    }
+    return Math.min(peak, 0xffff_ffff)
+}
+
+export function receiveFits(
+    dest: UnwrapDestination &
+        sched.ScheduleData & {
+            cargomass: number | {toNumber(): number}
+            capacity?: number | {toNumber(): number}
+            holds?: {
+                kind: number | {toNumber(): number}
+                incoming_mass: number | {toNumber(): number}
+            }[]
+        },
+    item: UnwrapItem,
+    now: Date
+): boolean {
+    const capacity = Number(dest.capacity ?? 0)
+    if (capacity <= 0) return false
+    const itemMass = Number(
+        calcCargoItemMass({
+            item_id: item.itemId as never,
+            quantity: item.quantity as never,
+            modules: item.modules,
+        })
+    )
+    const duration = estimateUnwrapDuration(dest, item)
+    const candidateCompletes = candidateLaneCompletesAt(dest, sched.LANE_MOBILITY, duration, now)
+    const peak = projectedPeakCargomass(
+        dest,
+        candidateCompletes,
+        itemMass + incomingHoldMass(dest.holds)
+    )
+    return peak <= capacity
+}

package/src/shipload.ts

@@ -1,34 +1,43 @@
 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'
+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 {CoordinatesManager} from './managers/coordinates'
 import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
+import type {ClusterManager} from './managers/cluster'
+import type {NftManager} from './managers/nft'
+import type {BalancesManager} from './managers/balances'
+import type {JobsManager} from './managers/jobs'
+import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
 import type {GameState} from './entities/gamestate'
 
 interface ShiploadOptions {
     platformContractName?: string
     serverContractName?: string
+    fundContractName?: string
     client?: APIClient
     subscriptionsUrl?: string
+    atomicAssetsAccount?: string
 }
 
 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
@@ -39,7 +48,15 @@ export class Shipload {
             ? serverContract
             : new ServerContract.Contract({client: apiClient})
 
-        this._context = new GameContext(apiClient, server, platform)
+        const fund = fundContract ? fundContract : new FundContract.Contract({client: apiClient})
+
+        this._context = new GameContext(
+            apiClient,
+            server,
+            platform,
+            constructorOptions?.atomicAssetsAccount ?? 'atomicassets',
+            fund
+        )
 
         if (constructorOptions?.subscriptionsUrl) {
             this._context.setSubscriptionsUrl(constructorOptions.subscriptionsUrl)
@@ -68,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,
         })
     }
 
@@ -79,6 +106,10 @@ export class Shipload {
         return this._context.client
     }
 
+    get atomicAssetsAccount(): string {
+        return this._context.atomicAssetsAccount
+    }
+
     get server(): Contract {
         return this._context.server
     }
@@ -87,6 +118,10 @@ export class Shipload {
         return this._context.platform
     }
 
+    get fund(): Contract {
+        return this._context.fund
+    }
+
     get entities(): EntitiesManager {
         return this._context.entities
     }
@@ -99,6 +134,10 @@ export class Shipload {
         return this._context.locations
     }
 
+    get coordinates(): CoordinatesManager {
+        return this._context.coordinates
+    }
+
     get epochs(): EpochsManager {
         return this._context.epochs
     }
@@ -107,6 +146,26 @@ export class Shipload {
         return this._context.actions
     }
 
+    get clusters(): ClusterManager {
+        return this._context.clusters
+    }
+
+    get nft(): NftManager {
+        return this._context.nft
+    }
+
+    get balances(): BalancesManager {
+        return this._context.balances
+    }
+
+    get jobs(): JobsManager {
+        return this._context.jobs
+    }
+
+    get influence(): InfluenceManager {
+        return this._context.influence
+    }
+
     get subscriptions(): SubscriptionsManager {
         return this._context.subscriptions
     }