@shipload/sdk 1.0.0-next.65 → 1.0.0-next.66

package/src/influence/influence.test.ts

@@ -1,5 +1,6 @@
 import {describe, expect, test} from 'bun:test'
-import {Checksum256} from '@wharfkit/antelope'
+import {Checksum256, UInt8, UInt16, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
 import {ITEM_ORE_T1, ITEM_PLATE, ITEM_CRYSTAL_T1} from '../data/item-ids'
 import {categoryIndex} from './categories'
 import {
@@ -19,7 +20,7 @@ import {
     popcount5,
 } from './demand'
 import {findDecomp, DECOMP_REGISTRY} from './decomp'
-import {contributeDuration} from './duration'
+import {depotTransferDuration, contributeDuration} from './duration'
 import {getStatCount, statsSumSq} from './quality'
 import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
 import {citizenryName, citizenryPatternCount} from './citizenry'
@@ -135,7 +136,7 @@ describe('decomposition', () => {
         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)
+        expect(DECOMP_REGISTRY.length).toBe(56)
     })
 
     test('the retired Workshop has no decomposition entry', () => {
@@ -145,7 +146,7 @@ describe('decomposition', () => {
     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)
+        expect(entry.processedMass).toBeGreaterThan(0)
         for (let i = 1; i < entry.buckets.length; i++) {
             const prev = entry.buckets[i - 1]
             const cur = entry.buckets[i]
@@ -250,18 +251,18 @@ describe('valuation', () => {
 
 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))
+        expect(contributeDuration(10)).toBeGreaterThan(0)
+        expect(contributeDuration(10_000)).toBeGreaterThan(contributeDuration(10))
     })
 
     test('splitting a haul costs more than one trip', () => {
-        const single = contributeDuration(100_000_000)
-        const hundred = contributeDuration(1_000_000) * 100
+        const single = contributeDuration(1_000_000)
+        const hundred = contributeDuration(10_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))
+        expect(contributeDuration(10, 0)).toBe(contributeDuration(10, 800))
     })
 })
 
@@ -315,3 +316,69 @@ describe('scales', () => {
         expect(NEED_FP_SCALE % INFLUENCE_ATOMIC_PER_POINT).toBe(0)
     })
 })
+
+describe('depot transfer duration', () => {
+    type ModuleEntry = ServerContract.Types.module_entry
+    const DEPOT_ITEM = 10219
+    const LOADER_T1 = 10103
+
+    function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
+        return {
+            type: UInt8.from(0),
+            installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
+        } as unknown as ModuleEntry
+    }
+    function emptySlot(): ModuleEntry {
+        return {type: UInt8.from(0)} as unknown as ModuleEntry
+    }
+
+    // A spawned depot: loader in slot 0, four empty bays after it.
+    const depotWithLoader = (): ModuleEntry[] => [
+        makeModuleEntry(LOADER_T1, packStats(500)),
+        emptySlot(),
+        emptySlot(),
+        emptySlot(),
+        emptySlot(),
+    ]
+    const params = (overrides: Record<string, unknown> = {}) => ({
+        depotModules: depotWithLoader(),
+        depotItemId: DEPOT_ITEM,
+        depotKind: 'depot',
+        depotZ: 0,
+        shipKind: 'ship',
+        shipZ: 0,
+        cargoMass: 100,
+        ...overrides,
+    })
+
+    test('drives off the depot loader, not the ship', () => {
+        expect(depotTransferDuration(params())).toBeGreaterThan(0)
+    })
+
+    test('grows with cargo mass', () => {
+        expect(depotTransferDuration(params({cargoMass: 10_000}))).toBeGreaterThan(
+            depotTransferDuration(params({cargoMass: 100}))
+        )
+    })
+
+    test('empty cargo costs nothing', () => {
+        expect(depotTransferDuration(params({cargoMass: 0}))).toBe(0)
+    })
+
+    test('a depot with no loader installed cannot transfer', () => {
+        expect(depotTransferDuration(params({depotModules: [emptySlot()]}))).toBe(0)
+    })
+
+    test('co-located transfers are floored at the orbital minimum distance', () => {
+        // max(planetary 100, orbital 200) = 200, so anything under 200 reads as 200
+        const touching = depotTransferDuration(params({shipZ: 0, depotZ: 0}))
+        const under = depotTransferDuration(params({shipZ: 150, depotZ: 0}))
+        const over = depotTransferDuration(params({shipZ: 400, depotZ: 0}))
+        expect(under).toBe(touching)
+        expect(over).toBeGreaterThan(touching)
+    })
+
+    test('never reports zero for real cargo', () => {
+        expect(depotTransferDuration(params({cargoMass: 1}))).toBeGreaterThanOrEqual(1)
+    })
+})

package/src/influence/valuation.ts

@@ -1,14 +1,14 @@
 import {getItem} from '../data/catalog'
+import {MASS_UNITS_PER_TONNE} from '../types'
 import {categoryIndex} from './categories'
 import {
     INFLUENCE_ATOMIC_PER_POINT,
-    INFLUENCE_MASS_KG_MAX,
+    INFLUENCE_MASS_MAX,
     INFLUENCE_NEED_FP_MAX,
     INFLUENCE_WEIGHT_FP_MAX,
-    MASS_KG_PER_TONNE,
     NEED_FP_SCALE,
     WEIGHT_FP_SCALE,
-    W_EFF_ATOMIC_PER_KG,
+    W_EFF_ATOMIC_PER_UNIT,
 } from './constants'
 import {findDecomp} from './decomp'
 import type {DemandView} from './demand'
@@ -29,16 +29,16 @@ export interface ValuedItem {
 }
 
 export function weightedQualityAtomic(
-    weightedKgFp: bigint,
+    weightedMassFp: 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 num = weightedMassFp * BigInt(sumSq) * needFp
     const den =
-        (BigInt(MASS_KG_PER_TONNE) *
+        (BigInt(MASS_UNITS_PER_TONNE) *
             BigInt(WEIGHT_FP_SCALE) *
             BigInt(nStats) *
             BigInt(d1) *
@@ -48,34 +48,34 @@ export function weightedQualityAtomic(
 }
 
 export function resourceValueAtomic(
-    massKg: bigint,
+    mass: 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 (mass > INFLUENCE_MASS_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)
+    return weightedQualityAtomic(mass * weightFp, sumSq, nStats, d1, needFp)
 }
 
 export function componentBaseAtomic(
-    weightedRawKgFp: bigint,
+    weightedRawMassFp: bigint,
     sumSq: number,
     nStats: number,
     d1: number
 ): bigint {
-    return weightedQualityAtomic(weightedRawKgFp, sumSq, nStats, d1, BigInt(NEED_FP_SCALE))
+    return weightedQualityAtomic(weightedRawMassFp, 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) {
+export function componentEffortAtomic(processedMassPerUnit: number, quantity: number): bigint {
+    const processed = BigInt(processedMassPerUnit) * BigInt(quantity)
+    if (processed > INFLUENCE_MASS_MAX) {
         throw new Error('influence: processed mass out of range')
     }
-    return processed * W_EFF_ATOMIC_PER_KG
+    return processed * W_EFF_ATOMIC_PER_UNIT
 }
 
 export function valueCargoItem(
@@ -114,14 +114,14 @@ export function valueCargoItem(
 
     let weighted = 0n
     for (const bucket of entry.buckets) {
-        weighted += BigInt(bucket.rawKg) * pricing.weight(bucket.category, bucket.tier)
+        weighted += BigInt(bucket.rawMass) * 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)
+    const withEffort = total + componentEffortAtomic(entry.processedMass, item.quantity)
     if (withEffort > UINT64_MAX) throw new Error('influence: component value overflow')
     return withEffort
 }

package/src/managers/actions.ts

@@ -25,8 +25,9 @@ import {ServerContract, TokenContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
 
-const CHARGE_K = 1n
-const ENERGY_DIVISOR = 1_000_000n
+const CHARGE_K = 100n
+const ENERGY_DIVISOR = 10n
+const ENERGY_FLOOR = 1_000n
 const UINT32_MAX = 4_294_967_295
 const UINT32_MAX_BIGINT = 4_294_967_295n
 const UINT32_MOD = 4_294_967_296n
@@ -99,6 +100,12 @@ function clampLaunchResult(value: bigint): number {
     return Number(value)
 }
 
+function clampEnergyResult(value: bigint): number {
+    if (value < ENERGY_FLOOR) return Number(ENERGY_FLOOR)
+    if (value > UINT32_MAX_BIGINT) return UINT32_MAX
+    return Number(value)
+}
+
 function toUint32(value: bigint): bigint {
     return value % UINT32_MOD
 }
@@ -133,7 +140,8 @@ function calcPayloadMass(items: ServerContract.ActionParams.Type.cargo_item[]):
 
 function calcChargeTime(chargeRate: number, mass: bigint): number {
     const rate = BigInt(chargeRate || 1)
-    return clampLaunchResult((mass * CHARGE_K) / rate)
+    const t = (mass * CHARGE_K) / rate
+    return clampLaunchResult(t + 1n)
 }
 
 function calcFlightTime(velocity: number, distance: bigint): number {
@@ -145,7 +153,7 @@ function calcLaunchEnergy(drain: number, mass: bigint, distance: bigint): number
     const e =
         saturatingMul(saturatingMul(mass, distance / PRECISION_BIGINT), BigInt(drain)) /
         ENERGY_DIVISOR
-    return clampLaunchResult(e)
+    return clampEnergyResult(e)
 }
 
 function calcMaxReach(energyBudget: bigint, mass: bigint, drain: number): bigint {
@@ -524,58 +532,51 @@ export class ActionsManager extends BaseManager {
         return this.server.action('clustercraft', params)
     }
 
-    claimjob(jobId: UInt64Type, shipId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.claimjob = {
+    claimcraft(jobId: UInt64Type, shipId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.claimcraft = {
             job_id: UInt64.from(jobId),
             ship_id: UInt64.from(shipId),
         }
-        return this.server.action('claimjob', params)
+        return this.server.action('claimcraft', params)
     }
 
-    canceljob(jobId: UInt64Type, shipId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.canceljob = {
+    cancelcraft(jobId: UInt64Type, shipId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelcraft = {
             job_id: UInt64.from(jobId),
             ship_id: UInt64.from(shipId),
         }
-        return this.server.action('canceljob', params)
+        return this.server.action('cancelcraft', params)
     }
 
-    upgradejob(
+    buildjob(
         targetId: UInt64Type,
         dockId: UInt64Type,
+        slot: UInt8Type,
         targetItemId: UInt16Type,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
-        const params: ServerContract.ActionParams.upgradejob = {
+        const params: ServerContract.ActionParams.buildjob = {
             target_id: UInt64.from(targetId),
             dock_id: UInt64.from(dockId),
+            slot: UInt8.from(slot),
             target_item_id: UInt16.from(targetItemId),
             inputs,
         }
-        return this.server.action('upgradejob', params)
+        return this.server.action('buildjob', params)
     }
 
-    claimupgrade(jobId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.claimupgrade = {
+    claimbuild(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.claimbuild = {
             job_id: UInt64.from(jobId),
         }
-        return this.server.action('claimupgrade', params)
+        return this.server.action('claimbuild', params)
     }
 
-    cancelupgrade(jobId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.cancelupgrade = {
+    cancelbuild(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelbuild = {
             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),
-            slot: UInt8.from(slot),
-            open,
-        }
-        return this.server.action('setsocket', params)
+        return this.server.action('cancelbuild', params)
     }
 
     blend(entityId: UInt64Type, inputs: ServerContract.ActionParams.Type.cargo_item[]): Action {
@@ -844,6 +845,12 @@ export class ActionsManager extends BaseManager {
         return actions
     }
 
+    setunwrapmin(assetId: UInt64Type): Action {
+        return this.server.action('setunwrapmin', {
+            asset_id: UInt64.from(assetId),
+        })
+    }
+
     placecargo(owner: NameType, hostId: UInt64Type, assetId: UInt64Type): Action {
         return this.server.action('placecargo', {
             owner: Name.from(owner),
@@ -982,6 +989,23 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    addFundToken(tokenContract: NameType, tokenSymbol: Asset.SymbolType): Action {
+        return this.fund.action('addtoken', {
+            token_contract: Name.from(tokenContract),
+            token_symbol: Asset.Symbol.from(tokenSymbol),
+        })
+    }
+
+    removeFundToken(tokenContract: NameType): Action {
+        return this.fund.action('deltoken', {
+            token_contract: Name.from(tokenContract),
+        })
+    }
+
+    collectFund(): Action {
+        return this.fund.action('collect', {})
+    }
+
     found(player: NameType, entityId: UInt64Type, location: CoordinatesType): Action {
         return this.server.action('found', {
             player: Name.from(player),
@@ -1043,18 +1067,22 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    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),
+    castballot(player: NameType, ballotId: UInt64Type, picks: number[]): Action {
+        return this.server.action('castballot', {
+            player,
+            ballot_id: UInt64.from(ballotId),
+            picks: picks.map((pick) => UInt32.from(pick)),
         })
     }
 
-    voteready(maxBallots: UInt32Type = UInt32.from(0)): Action {
-        return this.server.action('voteready', {
-            max_ballots: UInt32.from(maxBallots),
+    settleballot(ballotId: UInt64Type, maxPages: UInt32Type = UInt32.from(0)): Action {
+        return this.server.action('settleballot', {
+            ballot_id: UInt64.from(ballotId),
+            max_pages: UInt32.from(maxPages),
         })
     }
+
+    voteready(maxPages: UInt32Type = UInt32.from(0)): Action {
+        return this.server.action('voteready', {max_pages: UInt32.from(maxPages)})
+    }
 }

package/src/managers/base.ts

@@ -15,6 +15,10 @@ export abstract class BaseManager {
         return this.context.platform
     }
 
+    protected get fund() {
+        return this.context.fund
+    }
+
     protected get atomicAssetsAccount() {
         return this.context.atomicAssetsAccount
     }

package/src/managers/context.ts

@@ -1,6 +1,7 @@
 import type {APIClient} from '@wharfkit/antelope'
 import type {Contract} from '@wharfkit/contract'
 import type {PlatformContract} from '../contracts'
+import {FundContract} from '../contracts'
 import {GameState} from '../entities/gamestate'
 
 import {EntitiesManager} from './entities'
@@ -38,7 +39,8 @@ export class GameContext {
         public readonly client: APIClient,
         public readonly server: Contract,
         public readonly platform: Contract,
-        public readonly atomicAssetsAccount: string = 'atomicassets'
+        public readonly atomicAssetsAccount: string = 'atomicassets',
+        public readonly fund: Contract = new FundContract.Contract({client})
     ) {}
 
     get entities(): EntitiesManager {

package/src/managers/index.ts

@@ -23,8 +23,10 @@ export type {
     FoundedWorld,
     FoundedWorldRef,
     InfluenceStanding,
-    PendingBallot,
-    VoteCast,
+    Ballot,
+    BallotVote,
+    NodeProgress,
+    QueuedSeat,
     VoteOption,
     VoteStandings,
 } from './influence'

package/src/managers/influence.test.ts

@@ -16,43 +16,41 @@ function managerWith(rowsByTable: Record<string, unknown[]>) {
 }
 
 describe('InfluenceManager scoped table reads', () => {
-    it('getVoteCasts scopes infvote by location and maps fields', async () => {
+    it('getBallotVotes scopes ballotpicks by ballot id and maps fields', async () => {
         const {manager, calls} = managerWith({
-            infvote: [{account: Name.from('eggmaple.gm'), epoch: 5, node_id: 2, weight: '100'}],
+            ballotpicks: [{account: Name.from('eggmaple.gm'), picks: [2, 1]}],
         })
-        const rows = await manager.getVoteCasts(LOCATION)
+        const rows = await manager.getBallotVotes(7n)
         expect(calls).toHaveLength(1)
-        expect(calls[0].table).toBe('infvote')
-        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
-        expect(rows).toEqual([
-            {account: Name.from('eggmaple.gm'), epoch: 5, nodeId: 2, weight: 100n},
-        ])
+        expect(calls[0].table).toBe('ballotpicks')
+        expect(UInt64.from(calls[0].scope as never).equals(UInt64.from(7))).toBe(true)
+        expect(rows).toEqual([{account: Name.from('eggmaple.gm'), picks: [2, 1]}])
     })
 
-    it('getVoteTallies scopes inftally by location and maps fields', async () => {
+    it('getBuiltCharters scopes mandates by location and maps fields', async () => {
         const {manager, calls} = managerWith({
-            inftally: [{node_id: 3, total: '250'}],
+            mandates: [{node_id: 1, repeats: 2}],
         })
-        const rows = await manager.getVoteTallies(LOCATION)
-        expect(calls[0].table).toBe('inftally')
+        const rows = await manager.getBuiltCharters(LOCATION)
+        expect(calls[0].table).toBe('mandates')
         expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
-        expect(rows).toEqual([{nodeId: 3, total: 250n}])
+        expect(rows).toEqual([{nodeId: 1, repeats: 2}])
     })
 
-    it('getBuiltCharters scopes charters by location and maps fields', async () => {
+    it('getBuildings scopes buildings by location and maps fields', async () => {
         const {manager, calls} = managerWith({
-            charters: [{node_id: 1, entity_id: '9001'}],
+            buildings: [{entity_id: '9001', building: 3}],
         })
-        const rows = await manager.getBuiltCharters(LOCATION)
-        expect(calls[0].table).toBe('charters')
+        const rows = await manager.getBuildings(LOCATION)
+        expect(calls[0].table).toBe('buildings')
         expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
-        expect(rows).toEqual([{nodeId: 1, entityId: 9001n}])
+        expect(rows).toEqual([{entityId: 9001n, building: 3}])
     })
 
     it('returns an empty array when the scope has no rows', async () => {
         const {manager} = managerWith({})
-        expect(await manager.getVoteCasts(LOCATION)).toEqual([])
-        expect(await manager.getVoteTallies(LOCATION)).toEqual([])
+        expect(await manager.getBallotVotes(7n)).toEqual([])
         expect(await manager.getBuiltCharters(LOCATION)).toEqual([])
+        expect(await manager.getBuildings(LOCATION)).toEqual([])
     })
 })