@shipload/sdk 1.0.0-next.62 → 1.0.0-next.63

package/src/influence/influence.test.ts

@@ -0,0 +1,291 @@
+import {describe, expect, test} from 'bun:test'
+import {Checksum256} from '@wharfkit/antelope'
+import {ITEM_ORE_T1, ITEM_PLATE, ITEM_CRYSTAL_T1} from '../data/item-ids'
+import {categoryIndex} from './categories'
+import {
+    CHARTER_WORKSHOP_COST,
+    DEMAND_TRIPLE_SEED,
+    INFLUENCE_ATOMIC_PER_POINT,
+    INFLUENCE_D1_SEED,
+    NEED_FP_SCALE,
+} from './constants'
+import {decayActive, normalizeActive} from './decay'
+import {
+    buildDemand,
+    deriveDemand,
+    lackingMaskFrom,
+    needForCategory,
+    pickAcuteCategory,
+    popcount5,
+} from './demand'
+import {findDecomp, DECOMP_REGISTRY} from './decomp'
+import {contributeDuration} from './duration'
+import {getStatCount, statsSumSq} from './quality'
+import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
+import {citizenryName} from './citizenry'
+
+const PAR = 213
+const WORLD = {x: 56, y: 0}
+const packStats = (a: number, b = a, c = a): bigint =>
+    BigInt(a) | (BigInt(b) << 10n) | (BigInt(c) << 20n)
+
+const SEED_WEIGHTS_FP = [10000, 10510, 14289, 21964, 32326, 42658, 52913, 61128, 68570, 75380]
+
+const pricing = pricingFromWeights(
+    INFLUENCE_D1_SEED,
+    Array.from({length: 5}, (_, category) =>
+        SEED_WEIGHTS_FP.map((weightFp, i) => ({category, tier: i + 1, weightFp}))
+    ).flat()
+)
+
+const baseDemand = buildDemand(0, 255, DEMAND_TRIPLE_SEED)
+
+describe('decay', () => {
+    test('zero epochs is the identity', () => {
+        expect(decayActive(1_000_000n, 0)).toBe(1_000_000n)
+    })
+
+    test('one epoch retains 19/20 with a floor', () => {
+        expect(decayActive(1_000_000n, 1)).toBe(950_000n)
+        expect(decayActive(19n, 1)).toBe(18n)
+    })
+
+    test('is path independent', () => {
+        const direct = decayActive(123_456_789n, 7)
+        const staged = decayActive(decayActive(123_456_789n, 3), 4)
+        expect(staged).toBe(direct)
+    })
+
+    test('early-exits at zero and clamps the iteration count', () => {
+        expect(decayActive(0n, 5_000)).toBe(0n)
+        expect(decayActive(1_000_000n, 100_000)).toBe(decayActive(1_000_000n, 1_024))
+    })
+
+    test('normalizeActive never decays backwards', () => {
+        expect(normalizeActive({active: 1_000n, lastUpdateEpoch: 9}, 4)).toBe(1_000n)
+    })
+})
+
+describe('quality', () => {
+    test('par stats give exactly the quality divisor', () => {
+        expect(statsSumSq(packStats(PAR), 3)).toBe(3 * INFLUENCE_D1_SEED)
+    })
+
+    test('the retired Workshop falls back to three stats', () => {
+        expect(getStatCount(10208)).toBe(3)
+    })
+
+    test('a crafted component reports its recipe slot count', () => {
+        expect(getStatCount(ITEM_PLATE)).toBe(3)
+    })
+})
+
+describe('demand', () => {
+    test('the lacking mask is the complement over five categories', () => {
+        expect(lackingMaskFrom(0b00101)).toBe(0b11010)
+        expect(popcount5(0b11010)).toBe(3)
+    })
+
+    test('the acute pick indexes the lacking set only', () => {
+        const lacking = 0b10010
+        expect(pickAcuteCategory(lacking, 0)).toBe(1)
+        expect(pickAcuteCategory(lacking, 1)).toBe(4)
+        expect(pickAcuteCategory(lacking, 2)).toBe(1)
+    })
+
+    test('the triple assigns peak, base and floor', () => {
+        const view = buildDemand(0b00001, 1, DEMAND_TRIPLE_SEED)
+        expect(needForCategory(view, 0)).toBe(DEMAND_TRIPLE_SEED.floor)
+        expect(needForCategory(view, 1)).toBe(DEMAND_TRIPLE_SEED.peak)
+        expect(needForCategory(view, 2)).toBe(DEMAND_TRIPLE_SEED.base)
+    })
+
+    test('the acute pick rotates with the epoch seed, not the game seed', () => {
+        const gameSeed = Checksum256.hash(Buffer.from('game'))
+        const coordinates = WORLD
+        const picks = new Set<number>()
+        for (let i = 0; i < 24; i++) {
+            const epochSeed = Checksum256.hash(Buffer.from(`epoch-${i}`))
+            picks.add(
+                deriveDemand({gameSeed, epochSeed, coordinates, triple: DEMAND_TRIPLE_SEED}).acute
+            )
+        }
+        expect(picks.size).toBeGreaterThan(1)
+    })
+
+    test('the composition partition is stable across epochs', () => {
+        const gameSeed = Checksum256.hash(Buffer.from('game'))
+        const coordinates = WORLD
+        const masks = new Set<number>()
+        for (let i = 0; i < 8; i++) {
+            const epochSeed = Checksum256.hash(Buffer.from(`epoch-${i}`))
+            masks.add(
+                deriveDemand({gameSeed, epochSeed, coordinates, triple: DEMAND_TRIPLE_SEED})
+                    .abundantMask
+            )
+        }
+        expect(masks.size).toBe(1)
+    })
+})
+
+describe('decomposition', () => {
+    test('the registry is sorted by item id and covers every recipe', () => {
+        for (let i = 1; i < DECOMP_REGISTRY.length; i++) {
+            expect(DECOMP_REGISTRY[i].itemId).toBeGreaterThan(DECOMP_REGISTRY[i - 1].itemId)
+        }
+        expect(DECOMP_REGISTRY.length).toBe(57)
+    })
+
+    test('the retired Workshop has no decomposition entry', () => {
+        expect(findDecomp(10208)).toBeUndefined()
+    })
+
+    test('buckets are sorted and hold only raw resources', () => {
+        const entry = findDecomp(ITEM_PLATE)
+        if (!entry) throw new Error('Plate has no decomposition entry')
+        expect(entry.processedKg).toBeGreaterThan(0)
+        for (let i = 1; i < entry.buckets.length; i++) {
+            const prev = entry.buckets[i - 1]
+            const cur = entry.buckets[i]
+            expect(prev.category < cur.category || prev.tier < cur.tier).toBe(true)
+        }
+    })
+})
+
+describe('valuation', () => {
+    test('a tonne of par T1 ore at base demand is worth exactly one point', () => {
+        const value = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 1, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(value).toBe(BigInt(INFLUENCE_ATOMIC_PER_POINT))
+    })
+
+    test('the acute multiplier doubles a resource', () => {
+        const acute = buildDemand(0, categoryIndex('crystal'), DEMAND_TRIPLE_SEED)
+        const item = {itemId: ITEM_CRYSTAL_T1, quantity: 3, stats: packStats(PAR)}
+        expect(valueCargoItem(item, acute, pricing)).toBe(
+            valueCargoItem(item, baseDemand, pricing) * 2n
+        )
+    })
+
+    test('resource valuation is split invariant', () => {
+        const one = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 1, stats: packStats(97)},
+            baseDemand,
+            pricing
+        )
+        const many = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 137, stats: packStats(97)},
+            baseDemand,
+            pricing
+        )
+        expect(many).toBe(one * 137n)
+    })
+
+    test('component valuation is split invariant', () => {
+        const one = valueCargoItem(
+            {itemId: ITEM_PLATE, quantity: 1, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        const many = valueCargoItem(
+            {itemId: ITEM_PLATE, quantity: 40, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(many).toBe(one * 40n)
+    })
+
+    test('components ignore demand entirely', () => {
+        const acute = buildDemand(0, categoryIndex('ore'), DEMAND_TRIPLE_SEED)
+        const item = {itemId: ITEM_PLATE, quantity: 5, stats: packStats(PAR)}
+        expect(valueCargoItem(item, acute, pricing)).toBe(valueCargoItem(item, baseDemand, pricing))
+    })
+
+    test('quality scales quadratically within the per-unit floor tolerance', () => {
+        const single = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 100, stats: packStats(100)},
+            baseDemand,
+            pricing
+        )
+        const doubled = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 100, stats: packStats(200)},
+            baseDemand,
+            pricing
+        )
+        const delta = doubled - single * 4n
+        expect(delta >= -105n && delta <= 105n).toBe(true)
+    })
+
+    test('a bundle totals its rows', () => {
+        const bundle = [
+            {itemId: ITEM_ORE_T1, quantity: 10, stats: packStats(PAR)},
+            {itemId: ITEM_PLATE, quantity: 2, stats: packStats(PAR)},
+        ]
+        expect(valueContribution(bundle, baseDemand, pricing)).toBe(
+            valueCargoItem(bundle[0], baseDemand, pricing) +
+                valueCargoItem(bundle[1], baseDemand, pricing)
+        )
+    })
+
+    test('a packed entity cannot be valued', () => {
+        expect(() =>
+            valueCargoItem({itemId: 10208, quantity: 1, stats: packStats(PAR)}, baseDemand, pricing)
+        ).toThrow()
+    })
+
+    test('the Workshop charter costs 200,000 points of hauled par T1 material', () => {
+        const perTonne = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 200_000, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(perTonne).toBe(CHARTER_WORKSHOP_COST)
+    })
+})
+
+describe('contribution duration', () => {
+    test('grows with mass and never falls below a single tick', () => {
+        expect(contributeDuration(1_000)).toBeGreaterThan(0)
+        expect(contributeDuration(1_000_000)).toBeGreaterThan(contributeDuration(1_000))
+    })
+
+    test('splitting a haul costs more than one trip', () => {
+        const single = contributeDuration(100_000_000)
+        const hundred = contributeDuration(1_000_000) * 100
+        expect(hundred).toBeGreaterThan(single)
+    })
+
+    test('ground level is floored at the base orbital climb', () => {
+        expect(contributeDuration(1_000, 0)).toBe(contributeDuration(1_000, 800))
+    })
+})
+
+describe('citizenry names', () => {
+    const gameSeed = Checksum256.hash(Buffer.from('game'))
+
+    test('is deterministic for a coordinate', () => {
+        const a = citizenryName(gameSeed, WORLD)
+        const b = citizenryName(gameSeed, WORLD)
+        expect(a).toBeDefined()
+        expect(a).toBe(b as string)
+    })
+
+    test('composes the world name', () => {
+        const name = citizenryName(gameSeed, WORLD) ?? ''
+        expect(name.length).toBeGreaterThan(0)
+        expect(/Collective|Compact|Concord of|Union/.test(name)).toBe(true)
+    })
+
+    test('is undefined away from a world', () => {
+        expect(citizenryName(gameSeed, {x: 7, y: 11})).toBeUndefined()
+    })
+})
+
+describe('scales', () => {
+    test('the need scale divides out against the atomic unit', () => {
+        expect(NEED_FP_SCALE % INFLUENCE_ATOMIC_PER_POINT).toBe(0)
+    })
+})

package/src/influence/quality.ts

@@ -0,0 +1,25 @@
+import {getRecipe} from '../data/recipes-runtime'
+import {decodeStat} from '../derivation/crafting'
+
+const CRAFTED_ITEM_ID_FLOOR = 10_000
+const UNCRAFTED_STAT_COUNT = 3
+
+export function getStatCount(itemId: number): number {
+    if (itemId < CRAFTED_ITEM_ID_FLOOR) return UNCRAFTED_STAT_COUNT
+    const recipe = getRecipe(itemId)
+    return recipe ? recipe.statSlots.length : UNCRAFTED_STAT_COUNT
+}
+
+export function statsSumSq(packedStats: bigint, nStats: number): number {
+    let sum = 0
+    for (let i = 0; i < nStats; i++) {
+        const s = decodeStat(packedStats, i)
+        sum += s * s
+    }
+    return sum
+}
+
+export function qualityFactor(packedStats: bigint, nStats: number, d1: number): number {
+    if (nStats <= 0 || d1 <= 0) throw new Error('influence: invalid quality divisor')
+    return statsSumSq(packedStats, nStats) / (nStats * d1)
+}

package/src/influence/valuation.ts

@@ -0,0 +1,154 @@
+import {getItem} from '../data/catalog'
+import {categoryIndex} from './categories'
+import {
+    INFLUENCE_ATOMIC_PER_POINT,
+    INFLUENCE_MASS_KG_MAX,
+    INFLUENCE_NEED_FP_MAX,
+    INFLUENCE_WEIGHT_FP_MAX,
+    MASS_KG_PER_TONNE,
+    NEED_FP_SCALE,
+    WEIGHT_FP_SCALE,
+    W_EFF_ATOMIC_PER_KG,
+} from './constants'
+import {findDecomp} from './decomp'
+import type {DemandView} from './demand'
+import {needForCategory} from './demand'
+import {getStatCount, statsSumSq} from './quality'
+
+const UINT64_MAX = (1n << 64n) - 1n
+
+export interface InfluencePricing {
+    d1: number
+    weight(category: number, tier: number): bigint
+}
+
+export interface ValuedItem {
+    itemId: number
+    quantity: number
+    stats: bigint
+}
+
+export function weightedQualityAtomic(
+    weightedKgFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number,
+    needFp: bigint
+): bigint {
+    if (nStats <= 0 || d1 <= 0) throw new Error('influence: invalid quality divisor')
+    const num = weightedKgFp * BigInt(sumSq) * needFp
+    const den =
+        (BigInt(MASS_KG_PER_TONNE) *
+            BigInt(WEIGHT_FP_SCALE) *
+            BigInt(nStats) *
+            BigInt(d1) *
+            BigInt(NEED_FP_SCALE)) /
+        BigInt(INFLUENCE_ATOMIC_PER_POINT)
+    return num / den
+}
+
+export function resourceValueAtomic(
+    massKg: bigint,
+    weightFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number,
+    needFp: bigint
+): bigint {
+    if (massKg > INFLUENCE_MASS_KG_MAX) throw new Error('influence: mass out of range')
+    if (weightFp > INFLUENCE_WEIGHT_FP_MAX) throw new Error('influence: weight out of range')
+    if (needFp > INFLUENCE_NEED_FP_MAX) throw new Error('influence: need out of range')
+    return weightedQualityAtomic(massKg * weightFp, sumSq, nStats, d1, needFp)
+}
+
+export function componentBaseAtomic(
+    weightedRawKgFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number
+): bigint {
+    return weightedQualityAtomic(weightedRawKgFp, sumSq, nStats, d1, BigInt(NEED_FP_SCALE))
+}
+
+export function componentEffortAtomic(processedKgPerUnit: number, quantity: number): bigint {
+    const processed = BigInt(processedKgPerUnit) * BigInt(quantity)
+    if (processed > INFLUENCE_MASS_KG_MAX) {
+        throw new Error('influence: processed mass out of range')
+    }
+    return processed * W_EFF_ATOMIC_PER_KG
+}
+
+export function valueCargoItem(
+    item: ValuedItem,
+    demand: DemandView,
+    pricing: InfluencePricing
+): bigint {
+    const def = getItem(item.itemId)
+    if (def.type !== 'resource' && def.type !== 'component') {
+        throw new Error('item class cannot be valued')
+    }
+
+    const nStats = getStatCount(item.itemId)
+    const sumSq = statsSumSq(item.stats, nStats)
+
+    if (def.type === 'resource') {
+        if (def.category === undefined) throw new Error('resource has no category')
+        const category = categoryIndex(def.category)
+        const weightFp = pricing.weight(category, def.tier)
+        const needFp = needForCategory(demand, category)
+        const perUnit = resourceValueAtomic(
+            BigInt(def.mass),
+            weightFp,
+            sumSq,
+            nStats,
+            pricing.d1,
+            needFp
+        )
+        const total = perUnit * BigInt(item.quantity)
+        if (total > UINT64_MAX) throw new Error('influence: resource value overflow')
+        return total
+    }
+
+    const entry = findDecomp(item.itemId)
+    if (!entry) throw new Error('item has no decomposition')
+
+    let weighted = 0n
+    for (const bucket of entry.buckets) {
+        weighted += BigInt(bucket.rawKg) * pricing.weight(bucket.category, bucket.tier)
+    }
+
+    const perUnit = componentBaseAtomic(weighted, sumSq, nStats, pricing.d1)
+    const total = perUnit * BigInt(item.quantity)
+    if (total > UINT64_MAX) throw new Error('influence: component value overflow')
+
+    const withEffort = total + componentEffortAtomic(entry.processedKg, item.quantity)
+    if (withEffort > UINT64_MAX) throw new Error('influence: component value overflow')
+    return withEffort
+}
+
+export function valueContribution(
+    bundle: ValuedItem[],
+    demand: DemandView,
+    pricing: InfluencePricing
+): bigint {
+    let total = 0n
+    for (const item of bundle) total += valueCargoItem(item, demand, pricing)
+    if (total > UINT64_MAX) throw new Error('influence: contribution value overflow')
+    return total
+}
+
+export function pricingFromWeights(
+    d1: number,
+    weights: Iterable<{category: number; tier: number; weightFp: bigint | number | string}>
+): InfluencePricing {
+    const table = new Map<number, bigint>()
+    for (const row of weights) {
+        table.set(row.category * 16 + row.tier, BigInt(row.weightFp.toString()))
+    }
+    return {
+        d1,
+        weight(category: number, tier: number): bigint {
+            return table.get(category * 16 + tier) ?? 0n
+        },
+    }
+}

package/src/managers/actions.ts

@@ -315,6 +315,30 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    depotstore(
+        shipId: UInt64Type,
+        depotId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('depotstore', {
+            ship_id: UInt64.from(shipId),
+            depot_id: UInt64.from(depotId),
+            items,
+        })
+    }
+
+    depottake(
+        shipId: UInt64Type,
+        depotId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('depottake', {
+            ship_id: UInt64.from(shipId),
+            depot_id: UInt64.from(depotId),
+            items,
+        })
+    }
+
     shuttle(
         carrierId: UInt64Type,
         fromId: UInt64Type,
@@ -511,6 +535,35 @@ export class ActionsManager extends BaseManager {
         return this.server.action('canceljob', params)
     }
 
+    upgradejob(
+        targetId: UInt64Type,
+        dockId: UInt64Type,
+        targetItemId: UInt16Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const params: ServerContract.ActionParams.upgradejob = {
+            target_id: UInt64.from(targetId),
+            dock_id: UInt64.from(dockId),
+            target_item_id: UInt16.from(targetItemId),
+            inputs,
+        }
+        return this.server.action('upgradejob', params)
+    }
+
+    claimupgrade(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.claimupgrade = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('claimupgrade', params)
+    }
+
+    cancelupgrade(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelupgrade = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('cancelupgrade', params)
+    }
+
     setsocket(workshopId: UInt64Type, slot: UInt8Type, open: boolean): Action {
         const params: ServerContract.ActionParams.setsocket = {
             workshop_id: UInt64.from(workshopId),
@@ -599,6 +652,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    abandonplot(plotId: UInt64Type): Action {
+        return this.server.action('abandonplot', {
+            plot_id: UInt64.from(plotId),
+        })
+    }
+
     addmodule(
         entityId: UInt64Type,
         moduleIndex: number,
@@ -835,4 +894,80 @@ export class ActionsManager extends BaseManager {
             max_rows: UInt64.from(maxRows),
         })
     }
+
+    found(player: NameType, entityId: UInt64Type, location: CoordinatesType): Action {
+        return this.server.action('found', {
+            player: Name.from(player),
+            entity_id: UInt64.from(entityId),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    naturalize(player: NameType, location: CoordinatesType): Action {
+        return this.server.action('naturalize', {
+            player: Name.from(player),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    contribute(
+        player: NameType,
+        entityId: UInt64Type,
+        location: CoordinatesType,
+        bundle: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.platform.action('contribute', {
+            game: this.server.account,
+            player: Name.from(player),
+            entity_id: UInt64.from(entityId),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+            bundle,
+        })
+    }
+
+    // addcontrib asserts the citizenship rows exist, so naturalize must precede contribute.
+    firstContribution(
+        player: NameType,
+        entityId: UInt64Type,
+        location: CoordinatesType,
+        bundle: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action[] {
+        return [
+            this.naturalize(player, location),
+            this.contribute(player, entityId, location, bundle),
+        ]
+    }
+
+    mintready(maxMints?: UInt32Type): Action {
+        const params: {max_mints?: UInt32} = {}
+        if (maxMints !== undefined) {
+            params.max_mints = UInt32.from(maxMints)
+        }
+        return this.server.action('mintready', params)
+    }
+
+    charterready(location: CoordinatesType): Action {
+        return this.server.action('charterready', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    votecharter(player: NameType, location: CoordinatesType, nodeId: UInt32Type): Action {
+        return this.server.action('votecharter', {
+            player: Name.from(player),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+            node_id: UInt32.from(nodeId),
+        })
+    }
+
+    voteready(maxBallots: UInt32Type = UInt32.from(0)): Action {
+        return this.server.action('voteready', {
+            max_ballots: UInt32.from(maxBallots),
+        })
+    }
 }

package/src/managers/construction.ts

@@ -4,7 +4,7 @@ import type {ServerContract} from '../contracts'
 import {PlotManager} from './plot'
 import {getItem} from '../data/catalog'
 import {calc_build_duration} from '../capabilities/crafting'
-import {getLanes, getTasks} from '../scheduling/schedule'
+import {getLanes, getTasks, isIdle} from '../scheduling/schedule'
 import {HoldKind, TaskType} from '../types'
 import type {
     BuildableTarget,
@@ -34,6 +34,16 @@ export class ConstructionManager extends BaseManager {
         return null
     }
 
+    canAbandon(
+        entity: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        if (entity.kind.toString() !== 'plot') return false
+        if (!isIdle(entity)) return false
+        if (Number(entity.cargomass) !== 0) return false
+        return !cargo.some((c) => c.entity_id.equals(entity.id))
+    }
+
     eligibleSources(
         target: BuildableTarget,
         entities: ServerContract.Types.entity_info[],

package/src/managers/context.ts

@@ -12,6 +12,7 @@ import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
 import {JobsManager} from './jobs'
+import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -24,6 +25,7 @@ export class GameContext {
     private _clusters?: ClusterManager
     private _nft?: NftManager
     private _jobs?: JobsManager
+    private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -100,6 +102,13 @@ export class GameContext {
         return this._jobs
     }
 
+    get influence(): InfluenceManager {
+        if (!this._influence) {
+            this._influence = new InfluenceManager(this)
+        }
+        return this._influence
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/entities.ts

@@ -55,6 +55,17 @@ export class EntitiesManager extends BaseManager {
         return result as ServerContract.Types.entity_summary[]
     }
 
+    async getDepot(
+        depotId: UInt64Type,
+        owner: NameType | ServerContract.Types.player_row
+    ): 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 {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner