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

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 {
@@ -358,6 +366,28 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    civicshuttle(
+        buildingId: UInt64Type,
+        fromId: UInt64Type,
+        toId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('civicshuttle', {
+            building: UInt64.from(buildingId),
+            from_id: UInt64.from(fromId),
+            to_id: UInt64.from(toId),
+            items,
+        })
+    }
+
+    cancelcivic(buildingId: UInt64Type, laneKey: UInt8Type, fromId: UInt64Type): Action {
+        return this.server.action('cancelcivic', {
+            building: UInt64.from(buildingId),
+            lane_key: UInt8.from(laneKey),
+            from_id: UInt64.from(fromId),
+        })
+    }
+
     launch(
         launcherId: UInt64Type,
         catcherId: UInt64Type,
@@ -524,58 +554,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 +867,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),
@@ -975,6 +1004,18 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    setdeadline(deadline: UInt32Type): Action {
+        return this.server.action('setdeadline', {
+            deadline: UInt32.from(deadline),
+        })
+    }
+
+    closeepoch(epoch: UInt64Type): Action {
+        return this.server.action('closeepoch', {
+            epoch: UInt64.from(epoch),
+        })
+    }
+
     cleanrsvp(epoch: UInt64Type, maxRows: UInt64Type): Action {
         return this.server.action('cleanrsvp', {
             epoch: UInt64.from(epoch),
@@ -982,6 +1023,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 +1101,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/epochs.ts

@@ -1,8 +1,17 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {Checksum256, UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
 import type {ServerContract} from '../contracts'
 
+export const DEFAULT_EPOCH_DEADLINE = 10800
+
+const EMPTY_SEED = Checksum256.from('0'.repeat(64))
+
+export interface EpochQuorumState {
+    threshold: number
+    finalized: boolean
+}
+
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
         const game = await this.getGame()
@@ -56,6 +65,12 @@ export class EpochsManager extends BaseManager {
         return this.server.table('epoch').get(target)
     }
 
+    async getEpochState(epoch: UInt64Type): Promise<EpochQuorumState> {
+        const row = await this.getEpochRow(epoch)
+        if (!row) return {threshold: 0, finalized: false}
+        return {threshold: Number(row.threshold), finalized: !row.seed.equals(EMPTY_SEED)}
+    }
+
     async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
         const rows = await this.server.table('epoch').all()
         if (rows.length === 0) {
@@ -73,6 +88,22 @@ export class EpochsManager extends BaseManager {
         return cfg ? Number(cfg.threshold) : 0
     }
 
+    async getDeadline(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.deadline) : DEFAULT_EPOCH_DEADLINE
+    }
+
+    async getCloseDueAt(epoch: UInt64Type): Promise<Date> {
+        const info = await this.getByHeight(epoch)
+        const deadline = await this.getDeadline()
+        return new Date(info.start.getTime() + deadline * 1000)
+    }
+
+    async getSecondsUntilClose(epoch: UInt64Type): Promise<number> {
+        const dueAt = await this.getCloseDueAt(epoch)
+        return Math.ceil((dueAt.getTime() - Date.now()) / 1000)
+    }
+
     async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
         const target = UInt64.from(epoch)
         const rows = await this.server.table('commit').all()

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([])
     })
 })