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

package/src/managers/context.ts

@@ -13,6 +13,7 @@ import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
 import {BalancesManager} from './balances'
+import {FundManager} from './fund'
 import {JobsManager} from './jobs'
 import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
@@ -27,6 +28,7 @@ export class GameContext {
     private _clusters?: ClusterManager
     private _nft?: NftManager
     private _balances?: BalancesManager
+    private _funds?: FundManager
     private _jobs?: JobsManager
     private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
@@ -106,6 +108,13 @@ export class GameContext {
         return this._balances
     }
 
+    get funds(): FundManager {
+        if (!this._funds) {
+            this._funds = new FundManager(this)
+        }
+        return this._funds
+    }
+
     get jobs(): JobsManager {
         if (!this._jobs) {
             this._jobs = new JobsManager(this)

package/src/managers/fund.ts

@@ -0,0 +1,49 @@
+import {type Asset, Name, type NameType, type UInt16} from '@wharfkit/antelope'
+import type {FundContract} from '../contracts'
+import type {PlatformBalance} from './balances'
+import {BaseManager} from './base'
+
+export interface FundBeneficiary {
+    account: Name
+    bps: UInt16
+}
+
+export interface FundToken {
+    tokenContract: Name
+    symbol: Asset.Symbol
+}
+
+export interface FundAccrued {
+    tokenContract: Name
+    balance: Asset
+}
+
+/** Live fund ledger reads. Token custody can exceed the amounts accrued to beneficiaries. */
+export class FundManager extends BaseManager {
+    async getBeneficiaries(): Promise<FundBeneficiary[]> {
+        const rows = (await this.fund
+            .table('benefs', this.fund.account)
+            .all()) as FundContract.Types.benef_row[]
+        return rows.map((row) => ({account: row.account, bps: row.bps}))
+    }
+
+    async getTokens(): Promise<FundToken[]> {
+        const rows = (await this.fund
+            .table('tokens', this.fund.account)
+            .all()) as FundContract.Types.token_row[]
+        return rows.map((row) => ({tokenContract: row.token_contract, symbol: row.token_symbol}))
+    }
+
+    /** Includes zero rows and claims for tokens no longer accepted; no rows returns []. */
+    async getAccrued(beneficiary: NameType): Promise<FundAccrued[]> {
+        const rows = (await this.fund
+            .table('accrued', Name.from(beneficiary))
+            .all()) as FundContract.Types.accrued_row[]
+        return rows.map((row) => ({tokenContract: row.token_contract, balance: row.balance}))
+    }
+
+    /** Platform balances that have not reached the fund's accrual ledger yet. */
+    async getUncollected(): Promise<PlatformBalance[]> {
+        return this.context.balances.getPlatformBalances(this.fund.account)
+    }
+}

package/src/managers/index.ts

@@ -44,3 +44,6 @@ export type {
     ScheduledBuild,
     Reservation,
 } from './construction-types'
+
+export {FundManager} from './fund'
+export type {FundBeneficiary, FundToken, FundAccrued} from './fund'

package/src/nft/description.ts

@@ -32,6 +32,7 @@ import {MASS_UNITS_PER_TONNE, type ModuleType} from '../types'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getBaseHullmassFor} from '../derivation/capabilities'
 import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
+import {resolveCapacityFnName, type CapacityFnName} from '../derivation/capacity-fn-registry'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -89,24 +90,18 @@ export function computeBaseCapacityDepot(stats: bigint): number {
     return Math.floor(500_000 * 6 ** (s / 1998))
 }
 
-const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
+const CAPACITY_FN_BY_NAME: Record<CapacityFnName, (stats: bigint) => number> = {
     ship: computeBaseCapacityShip,
     warehouse: computeBaseCapacityWarehouse,
     workshop: computeBaseCapacityWorkshop,
-    extractor: computeBaseCapacityContainer,
-    factory: computeBaseCapacityContainer,
-    builddock: computeBaseCapacityContainer,
-    mdriver: computeBaseCapacityContainer,
-    mcatcher: computeBaseCapacityContainer,
     container: computeBaseCapacityContainer,
-    nexus: computeBaseCapacityContainer,
     depot: computeBaseCapacityDepot,
 }
 
 export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {
-    const kind = getTemplateMeta(itemId)?.kind
-    if (!kind) return 0
-    return CAPACITY_FN_BY_KIND[kind.toString()]?.(stats) ?? 0
+    const fnName = resolveCapacityFnName(itemId)
+    if (!fnName) return 0
+    return CAPACITY_FN_BY_NAME[fnName](stats)
 }
 
 export const computeEngineThrust = (vol: number, tier: number): number =>

package/src/resolution/resolve-item.test.ts

@@ -2,11 +2,16 @@ import {expect, test} from 'bun:test'
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import {resolveItem} from './resolve-item'
 import {encodeStats} from '../derivation/crafting'
-import {computeBaseHullmass, computeContainerCapabilities} from '../derivation/capabilities'
 import {
-    ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_FACTORY_T1_PACKED,
-    ITEM_HUB_T1_PACKED,
+    computeBaseHullmass,
+    computeContainerCapabilities,
+    applyCapacityTier,
+} from '../derivation/capabilities'
+import {getItem} from '../data/catalog'
+import {
+    ITEM_EXTRACTOR_T2_PACKED,
+    ITEM_FACTORY_T2_PACKED,
+    ITEM_HUB_T2_PACKED,
     ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_MASS_CATCHER_T1_PACKED,
 } from '../data/item-ids'
@@ -16,8 +21,8 @@ function hullStats(strength: number, density: number, hardness: number): UInt64
 }
 
 const CONTAINER_ENTITIES = [
-    ['factory', ITEM_FACTORY_T1_PACKED],
-    ['extractor', ITEM_EXTRACTOR_T1_PACKED],
+    ['factory', ITEM_FACTORY_T2_PACKED],
+    ['extractor', ITEM_EXTRACTOR_T2_PACKED],
     ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
     ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
 ] as const
@@ -28,21 +33,21 @@ for (const [label, itemId] of CONTAINER_ENTITIES) {
         const resolved = resolveItem(UInt16.from(itemId), stats)
         const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
         const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
-        const expected = computeContainerCapabilities({
+        const base = computeContainerCapabilities({
             strength: 300,
             hardness: 400,
             density: 100,
         }).capacity
-        expect(capacity).toBe(expected)
+        expect(capacity).toBe(applyCapacityTier(base, getItem(itemId).tier))
     })
 }
 
 test('resolveItem resolves the station hub with hullmass and zero cargo capacity', () => {
     const stats = hullStats(300, 100, 400)
-    const resolved = resolveItem(UInt16.from(ITEM_HUB_T1_PACKED), stats)
+    const resolved = resolveItem(UInt16.from(ITEM_HUB_T2_PACKED), stats)
     const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
     expect(hull?.attributes.find((a) => a.label === 'Mass')?.value).toBe(
-        computeBaseHullmass(ITEM_HUB_T1_PACKED, {density: 100})
+        computeBaseHullmass(ITEM_HUB_T2_PACKED, {density: 100})
     )
     expect(hull?.attributes.find((a) => a.label === 'Capacity')?.value).toBe(0)
 })

package/src/shipload.ts

@@ -13,6 +13,7 @@ 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 {FundManager} from './managers/fund'
 import type {JobsManager} from './managers/jobs'
 import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
@@ -154,6 +155,10 @@ export class Shipload {
         return this._context.nft
     }
 
+    get funds(): FundManager {
+        return this._context.funds
+    }
+
     get balances(): BalancesManager {
         return this._context.balances
     }