@shipload/sdk 1.0.0-next.42 → 1.0.0-next.44

package/src/managers/actions.ts

@@ -17,7 +17,7 @@ import {
     type UInt64Type,
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Coordinates, PRECISION, type CoordinatesType} from '../types'
+import {Coordinates, PRECISION, type ClusterSlotType, type CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
@@ -435,22 +435,39 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    deploy(entityId: UInt64Type, ref: ServerContract.ActionParams.Type.cargo_ref): Action {
+    deploy(
+        entityId: UInt64Type,
+        ref: ServerContract.ActionParams.Type.cargo_ref,
+        slot?: ClusterSlotType
+    ): Action {
         return this.server.action('deploy', {
             id: UInt64.from(entityId),
             ref,
+            slot: slot ? {hub: UInt64.from(slot.hub), gx: slot.gx, gy: slot.gy} : undefined,
         })
     }
 
-    claimplot(
-        entityId: UInt64Type,
-        targetItemId: UInt16Type,
-        coords: ServerContract.ActionParams.Type.coordinates
-    ): Action {
+    claimplot(entityId: UInt64Type, targetItemId: UInt16Type, slot: ClusterSlotType): Action {
         return this.server.action('claimplot', {
             builder_id: UInt64.from(entityId),
             target_item_id: UInt16.from(targetItemId),
-            coords,
+            slot: {hub: UInt64.from(slot.hub), gx: slot.gx, gy: slot.gy},
+        })
+    }
+
+    movetile(
+        hubId: UInt64Type,
+        fromGx: number,
+        fromGy: number,
+        toGx: number,
+        toGy: number
+    ): Action {
+        return this.server.action('movetile', {
+            hub_id: UInt64.from(hubId),
+            from_gx: fromGx,
+            from_gy: fromGy,
+            to_gx: toGx,
+            to_gy: toGy,
         })
     }
 
@@ -593,6 +610,23 @@ export class ActionsManager extends BaseManager {
         )
     }
 
+    sendAsset(owner: NameType, recipient: NameType, assetId: UInt64Type, memo = ''): Action {
+        return Action.from(
+            {
+                account: this.atomicAssetsAccount,
+                name: 'transfer',
+                authorization: [{actor: Name.from(owner), permission: 'active'}],
+                data: {
+                    from: Name.from(owner),
+                    to: Name.from(recipient),
+                    asset_ids: [UInt64.from(assetId)],
+                    memo,
+                },
+            },
+            ATOMICASSETS_ABI
+        )
+    }
+
     // Two top-level actions the wallet signs to unwrap an NFT into a host's cargo.
     unwrapCargoTx(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action[] {
         return [this.transferForUnwrap(owner, assetId), this.placecargo(owner, hostId, assetId)]

package/src/managers/cluster.test.ts

@@ -0,0 +1,39 @@
+import {describe, expect, test} from 'bun:test'
+import {computeFreeCells} from './cluster'
+
+describe('computeFreeCells', () => {
+    test('returns footprint cells that are not occupied', () => {
+        const footprint = [
+            {gx: 2, gy: 0},
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ]
+        const occupied = [{gx: 2, gy: 0, entity: 7}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ])
+    })
+
+    test('matches occupancy on signed coordinates', () => {
+        const footprint = [
+            {gx: -2, gy: 0},
+            {gx: 0, gy: -2},
+            {gx: -1, gy: 1},
+        ]
+        const occupied = [{gx: 0, gy: -2, entity: 9}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: -2, gy: 0},
+            {gx: -1, gy: 1},
+        ])
+    })
+
+    test('empty footprint yields no free cells', () => {
+        expect(computeFreeCells([], [])).toEqual([])
+    })
+
+    test('fully occupied footprint yields no free cells', () => {
+        const footprint = [{gx: 1, gy: 1}]
+        expect(computeFreeCells(footprint, [{gx: 1, gy: 1, entity: 3}])).toEqual([])
+    })
+})

package/src/managers/cluster.ts

@@ -0,0 +1,53 @@
+import {UInt16, type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface GridCell {
+    gx: number
+    gy: number
+}
+
+export interface ClusterCell extends GridCell {
+    entity: number
+}
+
+export interface Cluster {
+    root: number
+    cells: ClusterCell[]
+}
+
+export function computeFreeCells(footprint: GridCell[], occupied: ClusterCell[]): GridCell[] {
+    const taken = new Set(occupied.map((c) => `${c.gx},${c.gy}`))
+    return footprint.filter((c) => !taken.has(`${c.gx},${c.gy}`))
+}
+
+export class ClusterManager extends BaseManager {
+    async getFootprint(itemId: UInt16Type): Promise<GridCell[]> {
+        const res = (await this.server.readonly('getfootprint', {
+            item_id: UInt16.from(itemId),
+        })) as ServerContract.Types.footprint_result
+        return res.cells.map((c) => ({gx: Number(c.gx), gy: Number(c.gy)}))
+    }
+
+    async getCluster(hubId: UInt64Type): Promise<Cluster> {
+        const res = (await this.server.readonly('getcluster', {
+            hub_id: UInt64.from(hubId),
+        })) as ServerContract.Types.cluster_row
+        return {
+            root: Number(res.root),
+            cells: res.cells.map((c) => ({
+                gx: Number(c.gx),
+                gy: Number(c.gy),
+                entity: Number(c.entity),
+            })),
+        }
+    }
+
+    async freeCells(hubId: UInt64Type, hubItemId: UInt16Type): Promise<GridCell[]> {
+        const [footprint, cluster] = await Promise.all([
+            this.getFootprint(hubItemId),
+            this.getCluster(hubId),
+        ])
+        return computeFreeCells(footprint, cluster.cells)
+    }
+}

package/src/managers/context.ts

@@ -9,6 +9,7 @@ import {LocationsManager} from './locations'
 import {CoordinatesManager} from './coordinates'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
+import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
@@ -19,6 +20,7 @@ export class GameContext {
     private _coordinates?: CoordinatesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _clusters?: ClusterManager
     private _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
@@ -75,6 +77,13 @@ export class GameContext {
         return this._actions
     }
 
+    get clusters(): ClusterManager {
+        if (!this._clusters) {
+            this._clusters = new ClusterManager(this)
+        }
+        return this._clusters
+    }
+
     get nft(): NftManager {
         if (!this._nft) {
             this._nft = new NftManager(this)

package/src/managers/index.ts

@@ -8,6 +8,8 @@ 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'

package/src/nft/buildImmutableData.ts

@@ -198,16 +198,14 @@ export function buildModuleImmutable(
         }
         case MODULE_GATHERER: {
             const str = decodeStat(stats, 0)
-            const tol = decodeStat(stats, 1)
-            const con = decodeStat(stats, 2)
-            const ref = decodeStat(stats, 3)
+            const hrd = decodeStat(stats, 1)
+            const sat = decodeStat(stats, 2)
             base.push({first: 'strength', second: ['uint16', str]})
-            base.push({first: 'tolerance', second: ['uint16', tol]})
-            base.push({first: 'saturation', second: ['uint16', con]})
-            base.push({first: 'plasticity', second: ['uint16', ref]})
+            base.push({first: 'hardness', second: ['uint16', hrd]})
+            base.push({first: 'saturation', second: ['uint16', sat]})
             base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
-            base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
-            base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})
+            base.push({first: 'drain', second: ['uint16', computeGathererDrain(sat)]})
+            base.push({first: 'depth', second: ['uint16', computeGathererDepth(hrd, item.tier)]})
             break
         }
         case MODULE_LOADER: {
@@ -220,17 +218,17 @@ export function buildModuleImmutable(
             break
         }
         case MODULE_WARP: {
-            const res = decodeStat(stats, 0)
-            base.push({first: 'resonance', second: ['uint16', res]})
-            base.push({first: 'range', second: ['uint32', computeWarpRange(res)]})
+            const ref = decodeStat(stats, 0)
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'range', second: ['uint32', computeWarpRange(ref)]})
             break
         }
         case MODULE_CRAFTER: {
-            const rea = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 0)
             const con = decodeStat(stats, 1)
-            base.push({first: 'reactivity', second: ['uint16', rea]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
             base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
+            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(fin)]})
             base.push({first: 'drain', second: ['uint16', computeCrafterDrain(con)]})
             break
         }
@@ -267,13 +265,13 @@ export function buildModuleImmutable(
         case MODULE_HAULER: {
             const res = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
-            const ref = decodeStat(stats, 2)
+            const con = decodeStat(stats, 2)
             base.push({first: 'resonance', second: ['uint16', res]})
             base.push({first: 'plasticity', second: ['uint16', pla]})
-            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
             base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res)]})
             base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(pla)]})
-            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(ref)]})
+            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(con)]})
             break
         }
     }

package/src/nft/description.ts

@@ -107,7 +107,7 @@ export function entityDisplayName(itemId: number): string {
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
         case ITEM_EXTRACTOR_T1_PACKED:
-            return 'Extractor'
+            return 'Mining Rig'
         case ITEM_FACTORY_T1_PACKED:
             return 'Factory'
         case ITEM_CONTAINER_T1_PACKED:
@@ -124,19 +124,19 @@ export function moduleDisplayName(itemId: number): string {
         case ITEM_ENGINE_T1:
             return 'Engine'
         case ITEM_GENERATOR_T1:
-            return 'Generator'
+            return 'Reactor'
         case ITEM_GATHERER_T1:
-            return 'Gatherer'
+            return 'Limpet Bay'
         case ITEM_LOADER_T1:
-            return 'Loader'
+            return 'Shuttle Bay'
         case ITEM_CRAFTER_T1:
-            return 'Crafter'
+            return 'Fabricator'
         case ITEM_STORAGE_T1:
-            return 'Cargo Bay'
+            return 'Cargo Hold'
         case ITEM_HAULER_T1:
-            return 'Hauler'
+            return 'Tractor Beam'
         case ITEM_WARP_T1:
-            return 'Warp'
+            return 'Warp Drive'
         case ITEM_BATTERY_T1:
             return 'Battery Bank'
         default:

package/src/resolution/describe-module.ts

@@ -61,8 +61,8 @@ const TEMPLATES: Record<string, TemplateSpec> = {
         ],
         highlightKeys: ['yield', 'depth', 'drain'],
     },
-    loader: {
-        id: 'module.loader.description',
+    loading: {
+        id: 'module.loading.description',
         template: 'generates {thrust} thrust with a weight of {mass} per unit',
         params: [
             ['thrust', 'Thrust'],
@@ -70,8 +70,8 @@ const TEMPLATES: Record<string, TemplateSpec> = {
         ],
         highlightKeys: ['thrust', 'mass'],
     },
-    crafter: {
-        id: 'module.crafter.description',
+    crafting: {
+        id: 'module.crafting.description',
         template: 'manufactures items at {speed} speed while draining {drain} energy per second',
         params: [
             ['speed', 'Speed'],
@@ -91,8 +91,8 @@ const TEMPLATES: Record<string, TemplateSpec> = {
         params: [['capacity', 'Energy Capacity']],
         highlightKeys: ['capacity'],
     },
-    hauler: {
-        id: 'module.hauler.description',
+    hauling: {
+        id: 'module.hauling.description',
         template:
             'locks onto up to {capacity} targets at {efficiency} efficiency while draining {drain} energy per distance travelled per target',
         params: [

package/src/resolution/resolve-item.ts

@@ -198,7 +198,7 @@ function computeCapabilityGroup(
         case MODULE_LOADER: {
             const caps = computeLoaderCapabilities(stats)
             return {
-                capability: 'Loader',
+                capability: 'Loading',
                 attributes: [
                     {label: 'Mass', value: caps.mass},
                     {label: 'Thrust', value: caps.thrust},
@@ -209,7 +209,7 @@ function computeCapabilityGroup(
         case MODULE_CRAFTER: {
             const caps = computeCrafterCapabilities(stats)
             return {
-                capability: 'Crafter',
+                capability: 'Crafting',
                 attributes: [
                     {label: 'Speed', value: caps.speed},
                     {label: 'Drain', value: caps.drain},
@@ -219,7 +219,7 @@ function computeCapabilityGroup(
         case MODULE_HAULER: {
             const caps = computeHaulerCapabilities(stats)
             return {
-                capability: 'Hauler',
+                capability: 'Hauling',
                 attributes: [
                     {label: 'Capacity', value: caps.capacity},
                     {label: 'Efficiency', value: caps.efficiency},

package/src/scheduling/unwrap.test.ts

@@ -0,0 +1,60 @@
+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*10000; flight=floor(2*sqrt(d/accel))
+        const mass = 1000
+        const accel = (400 / mass) * 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)) * 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('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,187 @@
+import type {UInt16Type, UInt32Type} from '@wharfkit/antelope'
+import {calcCargoItemMass} from '../capabilities/storage'
+import type {ServerContract} from '../contracts'
+import {PRECISION} from '../types'
+import * as sched from './schedule'
+import {taskCargoEffect} from './availability'
+import {candidateLaneCompletesAt} from './lanes'
+
+const NFT_TRANSIT_THRUST = 400
+
+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) * 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(destZ, 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)
+    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

@@ -10,6 +10,7 @@ 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 {SubscriptionsManager} from './subscriptions/manager'
 import type {GameState} from './entities/gamestate'
@@ -123,6 +124,10 @@ export class Shipload {
         return this._context.actions
     }
 
+    get clusters(): ClusterManager {
+        return this._context.clusters
+    }
+
     get nft(): NftManager {
         return this._context.nft
     }