@shipload/sdk 1.0.0-next.19 → 1.0.0-next.20

package/src/entities/gamestate.ts

@@ -1,4 +1,4 @@
-import {Checksum256, Int64, type UInt64} from '@wharfkit/antelope'
+import {Checksum256, Int64, UInt64} from '@wharfkit/antelope'
 import {type PlatformContract, ServerContract} from '../contracts'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
 import {hasSystem} from '../utils/system'
@@ -34,7 +34,7 @@ export class GameState extends ServerContract.Types.state_row {
      * Get the current epoch number from the state
      */
     get currentEpoch(): UInt64 {
-        return this.epoch
+        return UInt64.from(this.epoch.toString())
     }
 
     /**
@@ -58,20 +58,6 @@ export class GameState extends ServerContract.Types.state_row {
         return this.enabled
     }
 
-    /**
-     * Get the current salt value (used for random number generation)
-     */
-    get currentSalt(): UInt64 {
-        return this.salt
-    }
-
-    /**
-     * Get the commit hash for the next epoch
-     */
-    get nextEpochCommit(): Checksum256 {
-        return this.commit
-    }
-
     /**
      * Calculate the current epoch from game config (if game is set)
      * This might differ from state.epoch if the blockchain hasn't advanced yet
@@ -90,7 +76,7 @@ export class GameState extends ServerContract.Types.state_row {
         if (!this._game) {
             return undefined
         }
-        return getEpochInfo(this._game, this.epoch)
+        return getEpochInfo(this._game, this.currentEpoch)
     }
 
     /**
@@ -131,13 +117,11 @@ export class GameState extends ServerContract.Types.state_row {
         enabled: boolean
         epoch: string
         hasSeed: boolean
-        hasCommit: boolean
     } {
         return {
             enabled: this.enabled,
             epoch: this.epoch.toString(),
             hasSeed: !this.seed.equals(Checksum256.from('0'.repeat(64))),
-            hasCommit: !this.commit.equals(Checksum256.from('0'.repeat(64))),
         }
     }
 }

package/src/entities/makers.ts

@@ -10,7 +10,7 @@ import {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
 import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
 import {computeEntityCapabilities} from '../derivation/capabilities'
-import type {InstalledModule} from './slot-multiplier'
+import {packedModulesToInstalled} from './slot-multiplier'
 
 export interface PackedModuleInput {
     itemId: number
@@ -69,19 +69,6 @@ function assignModulesToSlots(
     )
 }
 
-function toInstalledModules(entries: ServerContract.Types.module_entry[]): InstalledModule[] {
-    const installed: InstalledModule[] = []
-    entries.forEach((entry, slotIndex) => {
-        if (!entry.installed) return
-        installed.push({
-            slotIndex,
-            itemId: Number(entry.installed.item_id.value),
-            stats: BigInt(entry.installed.stats.toString()),
-        })
-    })
-    return installed
-}
-
 const ZERO_HULL_STATS: Record<string, number> = {
     density: 0,
     strength: 0,
@@ -126,7 +113,7 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
         const moduleEntries = assignModulesToSlots(layout, mods, entityLabel)
         info.modules = moduleEntries
 
-        const installed = toInstalledModules(moduleEntries)
+        const installed = packedModulesToInstalled(moduleEntries)
         const caps = computeEntityCapabilities(ZERO_HULL_STATS, packedItemId, installed, layout)
 
         if (state.hullmass !== undefined) {

package/src/entities/slot-multiplier.ts

@@ -1,4 +1,5 @@
 import type {EntitySlot} from '../data/recipes-runtime'
+import type {ServerContract} from '../contracts'
 
 export const U16_MAX = 65535
 
@@ -8,6 +9,21 @@ export interface InstalledModule {
     stats: bigint
 }
 
+export function packedModulesToInstalled(
+    entries: ServerContract.Types.module_entry[]
+): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        if (!entry.installed) return
+        installed.push({
+            slotIndex,
+            itemId: Number(entry.installed.item_id.value),
+            stats: BigInt(entry.installed.stats.toString()),
+        })
+    })
+    return installed
+}
+
 export function clampUint16(value: number): number {
     return Math.min(value, U16_MAX)
 }

package/src/errors.ts

@@ -16,8 +16,6 @@ export const REQUIRES_POSITIVE_VALUE = 'Value must be greater than zero.'
 export const PLAYER_ALREADY_JOINED = 'Player has already joined the game.'
 export const PLAYER_NOT_JOINED = 'Player has not joined the game.'
 export const PLAYER_NOT_FOUND = 'Cannot find player for given account name.'
-export const STARTER_ALREADY_CLAIMED =
-    'Starter ship already claimed; destroy existing ships to re-claim.'
 export const ENTITY_ALREADY_THERE = 'Entity cannot travel to the location it is already at.'
 export const SHIP_ALREADY_TRAVELING = 'Ship is already traveling.'
 export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy goods while traveling.'

package/src/index-module.ts

@@ -228,6 +228,7 @@ export {
     isFactory,
     isContainer,
     isNexus,
+    isPlot,
 } from './data/kind-registry'
 export type {EntityTypeName, KindMeta, TemplateMeta} from './data/kind-registry'
 export * from './capabilities'
@@ -422,7 +423,7 @@ export {
 
 export {formatMass, formatMassDelta, formatMassScaled, formatLocation} from './format'
 
-export {displayName, describeItem} from './resolution/display-name'
+export {displayName, baseName, describeItem} from './resolution/display-name'
 export type {DescribeOptions} from './resolution/display-name'
 
 export * from './subscriptions'

package/src/managers/actions.ts

@@ -1,8 +1,12 @@
 import {
-    type Action,
+    Action,
+    Checksum256,
+    type Checksum256Type,
     Int64,
     Name,
     type NameType,
+    UInt8,
+    type UInt8Type,
     UInt16,
     type UInt16Type,
     UInt32,
@@ -13,12 +17,6 @@ import {
 import {BaseManager} from './base'
 import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
-import {
-    buildImmutableData,
-    type ImmutableModuleSlot,
-    moduleSlotsForImmutable,
-} from '../nft/buildImmutableData'
-import {buildMintAssetAction, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 
 export type EntityRefInput = {
     entityType: NameType
@@ -169,7 +167,7 @@ export class ActionsManager extends BaseManager {
         coords: ServerContract.ActionParams.Type.coordinates
     ): Action {
         return this.server.action('claimplot', {
-            id: UInt64.from(entityId),
+            builder_id: UInt64.from(entityId),
             target_item_id: UInt16.from(targetItemId),
             coords,
         })
@@ -177,7 +175,7 @@ export class ActionsManager extends BaseManager {
 
     buildplot(entityId: UInt64Type, plotId: UInt64Type): Action {
         return this.server.action('buildplot', {
-            id: UInt64.from(entityId),
+            builder_id: UInt64.from(entityId),
             plot_id: UInt64.from(plotId),
         })
     }
@@ -208,37 +206,6 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    private async buildPairedMintAction(args: {
-        owner: NameType
-        itemId: number
-        quantity: number
-        stats: bigint
-        originX: number
-        originY: number
-        moduleSlots: ImmutableModuleSlot[]
-    }): Promise<Action> {
-        const nftCfg = await this.context.nft.getNftConfigForItem(args.itemId)
-        if (!nftCfg) {
-            throw new Error(`item ${args.itemId} has no nftconfig`)
-        }
-        const immutableData = buildImmutableData(
-            args.itemId,
-            args.quantity,
-            args.stats,
-            args.originX,
-            args.originY,
-            args.moduleSlots
-        )
-        return buildMintAssetAction({
-            authorizedMinter: Name.from(args.owner),
-            collectionName: SHIPLOAD_COLLECTION,
-            schemaName: nftCfg.schemaName,
-            templateId: nftCfg.templateId,
-            newAssetOwner: Name.from(args.owner),
-            immutableData,
-        })
-    }
-
     async wrap(
         owner: NameType,
         entityId: UInt64Type,
@@ -246,42 +213,15 @@ export class ActionsManager extends BaseManager {
         cargoId: UInt64Type,
         quantity: UInt64Type
     ): Promise<Action[]> {
-        const cargoIdKey = UInt64.from(cargoId)
-        const entityIdKey = UInt64.from(entityId)
-        const [cargoRow, entityRow] = (await Promise.all([
-            this.server.table('cargo').get(cargoIdKey),
-            this.server.table('entity').get(entityIdKey),
-        ])) as [
-            ServerContract.Types.cargo_row | undefined,
-            ServerContract.Types.entity_row | undefined,
-        ]
-        if (!cargoRow) {
-            throw new Error(`cargo row ${cargoIdKey} not found`)
-        }
-        if (!entityRow) {
-            throw new Error(`entity ${entityIdKey} not found`)
-        }
-
-        const quantityValue = UInt64.from(quantity)
-        const mintAction = await this.buildPairedMintAction({
-            owner,
-            itemId: Number(cargoRow.item_id.toString()),
-            quantity: Number(quantityValue.toString()),
-            stats: BigInt(cargoRow.stats.toString()),
-            originX: Number(entityRow.coordinates.x.toString()),
-            originY: Number(entityRow.coordinates.y.toString()),
-            moduleSlots: moduleSlotsForImmutable(cargoRow.modules),
-        })
-
         return [
-            this.server.action('wrap', {
+            this.platform.action('wrapcargo', {
+                game: this.server.account,
                 owner: Name.from(owner),
                 entity_id: UInt64.from(entityId),
                 nexus_id: UInt64.from(nexusId),
-                cargo_id: cargoIdKey,
-                quantity: quantityValue,
+                cargo_id: UInt64.from(cargoId),
+                quantity: UInt64.from(quantity),
             }),
-            mintAction,
         ]
     }
 
@@ -297,49 +237,66 @@ export class ActionsManager extends BaseManager {
         entityId: UInt64Type,
         nexusId: UInt64Type
     ): Promise<Action[]> {
-        const entityIdKey = UInt64.from(entityId)
-        const entityRow = (await this.server.table('entity').get(entityIdKey)) as
-            | ServerContract.Types.entity_row
-            | undefined
-        if (!entityRow) {
-            throw new Error(`entity ${entityIdKey} not found`)
-        }
-
-        const mintAction = await this.buildPairedMintAction({
-            owner,
-            itemId: Number(entityRow.item_id.toString()),
-            quantity: 1,
-            stats: BigInt(entityRow.stats.toString()),
-            originX: Number(entityRow.coordinates.x.toString()),
-            originY: Number(entityRow.coordinates.y.toString()),
-            moduleSlots: moduleSlotsForImmutable(entityRow.modules),
-        })
-
         return [
-            this.server.action('wrapentity', {
-                entity_id: entityIdKey,
+            this.platform.action('wrapentity', {
+                game: this.server.account,
+                owner: Name.from(owner),
+                entity_id: UInt64.from(entityId),
                 nexus_id: UInt64.from(nexusId),
             }),
-            mintAction,
         ]
     }
 
-    deploynft(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.deploynft = {
+    placecargo(owner: NameType, hostId: UInt64Type, assetId: UInt64Type): Action {
+        return this.server.action('placecargo', {
             owner: Name.from(owner),
+            host_id: UInt64.from(hostId),
             asset_id: UInt64.from(assetId),
-            target_nexus_id: UInt64.from(targetNexusId),
-        }
-        return this.server.action('deploynft', params)
+        })
     }
 
-    unwrapnft(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.unwrapnft = {
+    placeentity(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action {
+        return this.server.action('placeentity', {
             owner: Name.from(owner),
             asset_id: UInt64.from(assetId),
-            host_id: UInt64.from(hostId),
-        }
-        return this.server.action('unwrapnft', params)
+            target_nexus_id: UInt64.from(targetNexusId),
+        })
+    }
+
+    transferForUnwrap(owner: NameType, assetId: UInt64Type): Action {
+        return Action.from({
+            account: 'atomicassets',
+            name: 'transfer',
+            authorization: [{actor: Name.from(owner), permission: 'active'}],
+            data: {
+                from: Name.from(owner),
+                to: this.platform.account,
+                asset_ids: [UInt64.from(assetId)],
+                memo: 'unwrap',
+            },
+        })
+    }
+
+    // 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)]
+    }
+
+    // Two top-level actions the wallet signs to place an entity NFT at a nexus.
+    unwrapEntityTx(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action[] {
+        return [
+            this.transferForUnwrap(owner, assetId),
+            this.placeentity(owner, assetId, targetNexusId),
+        ]
+    }
+
+    setRamPayer(newPayer: NameType, assetId: UInt64Type): Action {
+        return Action.from({
+            account: 'atomicassets',
+            name: 'setrampayer',
+            authorization: [{actor: Name.from(newPayer), permission: 'active'}],
+            data: {new_payer: Name.from(newPayer), asset_id: UInt64.from(assetId)},
+        })
     }
 
     demolish(entityId: UInt64Type): Action {
@@ -351,4 +308,45 @@ export class ActionsManager extends BaseManager {
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }
+
+    commit(oracleId: NameType, epoch: UInt64Type, commit: Checksum256Type): Action {
+        return this.server.action('commit', {
+            oracle_id: Name.from(oracleId),
+            epoch: UInt64.from(epoch),
+            commit: Checksum256.from(commit),
+        })
+    }
+
+    reveal(oracleId: NameType, epoch: UInt64Type, reveal: Checksum256Type): Action {
+        return this.server.action('reveal', {
+            oracle_id: Name.from(oracleId),
+            epoch: UInt64.from(epoch),
+            reveal: Checksum256.from(reveal),
+        })
+    }
+
+    addoracle(oracleId: NameType): Action {
+        return this.server.action('addoracle', {
+            oracle_id: Name.from(oracleId),
+        })
+    }
+
+    removeoracle(oracleId: NameType): Action {
+        return this.server.action('removeoracle', {
+            oracle_id: Name.from(oracleId),
+        })
+    }
+
+    setthreshold(threshold: UInt8Type): Action {
+        return this.server.action('setthreshold', {
+            threshold: UInt8.from(threshold),
+        })
+    }
+
+    cleanrsvp(epoch: UInt64Type, maxRows: UInt64Type): Action {
+        return this.server.action('cleanrsvp', {
+            epoch: UInt64.from(epoch),
+            max_rows: UInt64.from(maxRows),
+        })
+    }
 }

package/src/managers/base.ts

@@ -19,7 +19,7 @@ export abstract class BaseManager {
         return this.context.getGame()
     }
 
-    protected async getState() {
-        return this.context.getState()
+    protected async getState(reload = false) {
+        return this.context.getState(reload)
     }
 }

package/src/managers/construction.ts

@@ -30,7 +30,7 @@ export class ConstructionManager extends BaseManager {
 
     eligibleSources(
         target: BuildableTarget,
-        entities: ServerContract.Types.entity_row[],
+        entities: ServerContract.Types.entity_info[],
         cargo: ServerContract.Types.cargo_row[]
     ): SourceEntityRef[] {
         return partitionSources(target, entities, cargo).eligible
@@ -38,7 +38,7 @@ export class ConstructionManager extends BaseManager {
 
     unreachableSources(
         target: BuildableTarget,
-        entities: ServerContract.Types.entity_row[],
+        entities: ServerContract.Types.entity_info[],
         cargo: ServerContract.Types.cargo_row[]
     ): SourceEntityRef[] {
         return partitionSources(target, entities, cargo).unreachable
@@ -46,7 +46,7 @@ export class ConstructionManager extends BaseManager {
 
     partitionSources(
         target: BuildableTarget,
-        entities: ServerContract.Types.entity_row[],
+        entities: ServerContract.Types.entity_info[],
         cargo: ServerContract.Types.cargo_row[]
     ): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
         return partitionSources(target, entities, cargo)
@@ -54,7 +54,7 @@ export class ConstructionManager extends BaseManager {
 
     eligibleFinalizers(
         target: BuildableTarget,
-        entities: ServerContract.Types.entity_row[]
+        entities: ServerContract.Types.entity_info[]
     ): FinalizerEntityRef[] {
         const out: FinalizerEntityRef[] = []
         for (const entity of entities) {
@@ -91,7 +91,7 @@ function coordsEqual(
 }
 
 function matchRelevantCargo(
-    entity: ServerContract.Types.entity_row,
+    entity: ServerContract.Types.entity_info,
     target: BuildableTarget,
     cargo: ServerContract.Types.cargo_row[]
 ): SourceCargoStack[] {
@@ -119,7 +119,7 @@ function matchRelevantCargo(
 
 function partitionSources(
     target: BuildableTarget,
-    entities: ServerContract.Types.entity_row[],
+    entities: ServerContract.Types.entity_info[],
     cargo: ServerContract.Types.cargo_row[]
 ): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
     const eligible: SourceEntityRef[] = []

package/src/managers/epochs.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import type {ServerContract} from '../contracts'
 
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
@@ -8,6 +9,11 @@ export class EpochsManager extends BaseManager {
         return getCurrentEpoch(game)
     }
 
+    async getFinalizedEpoch(reload = false): Promise<UInt64> {
+        const state = await this.getState(reload)
+        return state.currentEpoch
+    }
+
     async getCurrent(): Promise<EpochInfo> {
         const game = await this.getGame()
         const epoch = await this.getCurrentHeight()
@@ -44,4 +50,38 @@ export class EpochsManager extends BaseManager {
         const remaining = await this.getTimeRemaining()
         return durationMs <= remaining
     }
+
+    async getEpochRow(epoch: UInt64Type): Promise<ServerContract.Types.epoch_row | undefined> {
+        const target = UInt64.from(epoch)
+        return this.server.table('epoch').get(target)
+    }
+
+    async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
+        const rows = await this.server.table('epoch').all()
+        if (rows.length === 0) {
+            return undefined
+        }
+        return rows[rows.length - 1]
+    }
+
+    async getOracles(): Promise<ServerContract.Types.oracle_row[]> {
+        return this.server.table('oracles').all()
+    }
+
+    async getThreshold(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.threshold) : 0
+    }
+
+    async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('commit').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
+
+    async getRevealsFor(epoch: UInt64Type): Promise<ServerContract.Types.reveal_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('reveal').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
 }

package/src/managers/plot.ts

@@ -1,6 +1,6 @@
 import {Name} from '@wharfkit/antelope'
 import {getItem} from '../data/catalog'
-import {getRecipe, resolveRecipeInputItemId} from '../data/recipes-runtime'
+import {getRecipe} from '../data/recipes-runtime'
 import {computeInputMass} from '../derivation/crafting'
 import {calc_craft_duration} from '../capabilities/crafting'
 import {TaskType} from '../types'
@@ -47,7 +47,7 @@ export class PlotManager extends BaseManager {
         }
 
         const rows: PlotProgressInputRow[] = recipe.inputs.map((input) => {
-            const itemId = resolveRecipeInputItemId(input)
+            const itemId = input.itemId
             const required = input.quantity
             const provided = quantityByItemId.get(itemId) ?? 0
             const missing = Math.max(0, required - provided)
@@ -112,7 +112,7 @@ export class PlotManager extends BaseManager {
     }
 
     timeToComplete(
-        plot: ServerContract.Types.entity_row,
+        plot: ServerContract.Types.entity_info,
         crafter: ServerContract.Types.crafter_stats
     ): number {
         const capacity = Number(plot.capacity?.toString() ?? '0')

package/src/nft/buildImmutableData.ts

@@ -110,6 +110,9 @@ function commonBaseImmutable(
         {first: 'origin_x', second: ['int32', originX]},
         {first: 'origin_y', second: ['int32', originY]},
         {first: 'img', second: ['string', img]},
+        {first: 'deposit_amount', second: ['uint64', '0']},
+        {first: 'deposit_token', second: ['uint64', '0']},
+        {first: 'deposit_symbol', second: ['uint64', '0']},
     ]
 }
 

package/src/nft/description.ts

@@ -39,12 +39,12 @@ export function computeBaseHullmass(stats: bigint): number {
 
 export function computeBaseCapacityShip(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(5_000_000 * 10 ** (s / 2997))
+    return Math.floor(5_000_000 * 6 ** (s / 2997))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2) + decodeStat(stats, 3)
-    return Math.floor(100_000_000 * 10 ** (s / 2997))
+    return Math.floor(100_000_000 * 6 ** (s / 2997))
 }
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)

package/src/resolution/display-name.ts

@@ -30,15 +30,21 @@ function tierPrefix(item: DisplayNameInput): string | null {
     return null
 }
 
-function baseName(item: DisplayNameInput): string {
+function rootName(item: DisplayNameInput): string {
     if (itemTypeOf(item) !== 'resource') return item.name
     return item.category ? CATEGORY_LABELS[item.category] : 'Resource'
 }
 
-export function displayName(item: DisplayNameInput): string {
+// Tier-free display name: includes the resource tier adjective / component-module
+// prefix, but no "(T#)" suffix. Use this when the tier is shown separately.
+export function baseName(item: DisplayNameInput): string {
     const prefix = tierPrefix(item)
-    const head = prefix ? `${prefix} ${baseName(item)}` : baseName(item)
-    return `${head} (T${item.tier})`
+    const root = rootName(item)
+    return prefix ? `${prefix} ${root}` : root
+}
+
+export function displayName(item: DisplayNameInput): string {
+    return `${baseName(item)} (T${item.tier})`
 }
 
 export interface DescribeOptions {